Bug 42094: Refresh o.a.l.spi and o.a.l.helpers from log4j 1.3
git-svn-id: https://svn.apache.org/repos/asf/logging/sandbox/log4j/component@527680 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/src/main/java/org/apache/log4j/ULogger.java b/src/main/java/org/apache/log4j/ULogger.java
deleted file mode 100644
index abc2b65..0000000
--- a/src/main/java/org/apache/log4j/ULogger.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright 1999,2005 The Apache Software Foundation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.log4j;
-
-
-/**
- * A proxy for org.slf4j.ULogger. In slf4j implementing builds, this
- * interface will extend org.slf4j.ULogger and add no additional methods.
- *
- * @author Ceki Gülcü
- * @author Curt Arnold
- */
- public interface ULogger {
-
-
- /**
- * Is the logger instance enabled for the DEBUG level?
- * @return true if debug is enabled.
- */
- 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.
- *
- * <p>This form is useful in avoiding the superflous object creation
- * problem when invoking this method while it is disabled.
- * </p>
- * @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.
- *
- * <p>This form is useful in avoiding the superflous object creation
- * problem when invoking this method while it is disabled.
- * </p>
- * @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/main/java/org/apache/log4j/helpers/MessageFormatter.java b/src/main/java/org/apache/log4j/helpers/MessageFormatter.java
new file mode 100644
index 0000000..ad44e8e
--- /dev/null
+++ b/src/main/java/org/apache/log4j/helpers/MessageFormatter.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright 1999,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.log4j.helpers;
+
+
+/**
+ * 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 final class MessageFormatter {
+ /**
+ * Private formatter since all methods and members are static.
+ */
+ private MessageFormatter() {
+ super();
+ }
+
+ /**
+ * Start of replacement block.
+ */
+ private static final char DELIM_START = '{';
+ /**
+ * End of replacement block.
+ */
+ private static final char DELIM_STOP = '}';
+
+ /**
+ * Performs single argument substitution for the 'messagePattern' passed as
+ * parameter.
+ * <p/>
+ * For example, <code>MessageFormatter.format("Hi {}.", "there");</code>
+ * will return the string "Hi there.".
+ * <p/>
+ * 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(final String messagePattern,
+ final 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
+ // then we just return messagePattern
+ if (j == -1 || (j + 1 == len)) {
+ return messagePattern;
+ } else {
+ 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.
+ * <p/>
+ * For example, <code>MessageFormatter.format("Hi {}. My name is {}.",
+ * "there", "David");</code> will return the string
+ * "Hi there. My name is David.".
+ * <p/>
+ * 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(final String messagePattern,
+ final Object arg1,
+ final Object arg2) {
+ int i = 0;
+ int len = messagePattern.length();
+
+ StringBuffer sbuf = new StringBuffer(messagePattern.length() + 50);
+
+ for (int l = 0; l < 2; l++) {
+ int 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));
+ if (l == 0) {
+ sbuf.append(arg1);
+ } else {
+ sbuf.append(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/main/java/org/apache/log4j/spi/Component.java b/src/main/java/org/apache/log4j/spi/Component.java
new file mode 100644
index 0000000..28a39b4
--- /dev/null
+++ b/src/main/java/org/apache/log4j/spi/Component.java
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.log4j.spi;
+
+
+/**
+ * A common interface shared by log4j components.
+ *
+ * @author Ceki Gulcu
+ * @since 1.3
+ */
+public interface Component {
+
+
+ /**
+ * Set owning logger repository for this component. This operation can
+ * only be performed once.
+ * Once set, a subsequent attempt will throw an IllegalStateException.
+ *
+ * @param repository The repository where this appender is attached.
+ */
+ void setLoggerRepository(LoggerRepository repository);
+
+}
diff --git a/src/main/java/org/apache/log4j/spi/ComponentBase.java b/src/main/java/org/apache/log4j/spi/ComponentBase.java
new file mode 100644
index 0000000..7f32183
--- /dev/null
+++ b/src/main/java/org/apache/log4j/spi/ComponentBase.java
@@ -0,0 +1,121 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.log4j.spi;
+
+import org.apache.log4j.ULogger;
+
+
+/**
+ * Most log4j components derive from this class.
+ *
+ * @author Ceki Gulcu
+ * @since 1.3
+ */
+public class ComponentBase implements Component {
+
+ /**
+ * Error count limit.
+ */
+ private static final int ERROR_COUNT_LIMIT = 3;
+
+ /**
+ * Logger repository.
+ */
+ protected LoggerRepository repository;
+ /**
+ * Logger.
+ */
+ private ULogger logger;
+ /**
+ * Error count.
+ */
+ private int errorCount = 0;
+
+ /**
+ * Construct a new instance.
+ */
+ protected ComponentBase() {
+ super();
+ }
+
+
+ /**
+ * Called by derived classes when they deem that the component has recovered
+ * from an erroneous state.
+ */
+ protected void resetErrorCount() {
+ errorCount = 0;
+ }
+
+ /**
+ * Set the owning repository. The owning repository cannot be set more than
+ * once.
+ *
+ * @param repository repository
+ */
+ public void setLoggerRepository(final LoggerRepository repository) {
+ if (this.repository == null) {
+ this.repository = repository;
+ } else if (this.repository != repository) {
+ throw new IllegalStateException("Repository has been already set");
+ }
+ }
+
+ /**
+ * Return the {@link LoggerRepository} this component is attached to.
+ *
+ * @return Owning LoggerRepository
+ */
+ protected LoggerRepository getLoggerRepository() {
+ return repository;
+ }
+
+ /**
+ * Return an instance specific logger to be used by the component itself.
+ * This logger is not intended to be accessed by the end-user, hence the
+ * protected keyword.
+ * <p/>
+ * <p>In case the repository for this component is not set,
+ * this implementations returns a {@link SimpleULogger} instance.
+ *
+ * @return A ULogger instance.
+ */
+ protected ULogger getLogger() {
+ if (logger == null) {
+ if (repository != null) {
+ logger = repository.getLogger(this.getClass().getName());
+ } else {
+ logger = SimpleULogger.getLogger(this.getClass().getName());
+ }
+ }
+ return logger;
+ }
+
+ /**
+ * Frequently called methods in log4j components can invoke this method in
+ * order to avoid flooding the output when logging lasting error conditions.
+ *
+ * @return a regular logger, or a NOPLogger if called too frequently.
+ */
+ protected ULogger getNonFloodingLogger() {
+ if (errorCount++ >= ERROR_COUNT_LIMIT) {
+ return NOPULogger.NOP_LOGGER;
+ } else {
+ return getLogger();
+ }
+ }
+}
diff --git a/src/main/java/org/apache/log4j/spi/ErrorItem.java b/src/main/java/org/apache/log4j/spi/ErrorItem.java
new file mode 100644
index 0000000..f6f3686
--- /dev/null
+++ b/src/main/java/org/apache/log4j/spi/ErrorItem.java
@@ -0,0 +1,172 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.log4j.spi;
+
+import java.io.PrintStream;
+
+/**
+ * Used to store special log4j errors which cannot be logged using internal
+ * logging. Such errors include those occurring during the initial phases
+ * of log4j configuration or errors emanating from core components such as
+ * Logger or Hierarchy.
+ *
+ * @author Ceki Gulcu
+ */
+public class ErrorItem {
+ /**
+ * Message.
+ */
+ String message;
+ /**
+ * Column.
+ */
+ int colNumber = -1;
+ /**
+ * Line number.
+ */
+ int lineNumber = -1;
+ /**
+ * Exception.
+ */
+ Throwable exception;
+
+ /**
+ * Create new instance.
+ * @param message message
+ * @param e exception
+ */
+ public ErrorItem(final String message, final Exception e) {
+ super();
+ this.message = message;
+ exception = e;
+ }
+
+ /**
+ * Creaet new instance.
+ * @param message message.
+ */
+ public ErrorItem(final String message) {
+ this(message, null);
+ }
+
+ /**
+ * Get column number.
+ * @return column number.
+ */
+ public int getColNumber() {
+ return colNumber;
+ }
+
+ /**
+ * Set column number.
+ * @param colNumber new column number.
+ */
+ public void setColNumber(int colNumber) {
+ this.colNumber = colNumber;
+ }
+
+ /**
+ * Get exception.
+ * @return exception.
+ */
+ public Throwable getException() {
+ return exception;
+ }
+
+ /**
+ * Set exception.
+ * @param exception exception
+ */
+ public void setException(final Throwable exception) {
+ this.exception = exception;
+ }
+
+ /**
+ * Get line number.
+ * @return line number.
+ */
+ public int getLineNumber() {
+ return lineNumber;
+ }
+
+ /**
+ * Set line number.
+ * @param lineNumber line number.
+ */
+ public void setLineNumber(final int lineNumber) {
+ this.lineNumber = lineNumber;
+ }
+
+ /**
+ * Get message.
+ * @return message.
+ */
+ public String getMessage() {
+ return message;
+ }
+
+ /**
+ * Set message.
+ * @param message message.
+ */
+ public void setMessage(final String message) {
+ this.message = message;
+ }
+
+ /**
+ * String representation of ErrorItem.
+ * @return string.
+ */
+ public String toString() {
+ String str =
+ "Reported error: \"" + message + "\"";
+
+ if (lineNumber != -1) {
+ str += " at line " + lineNumber + " column " + colNumber;
+ }
+ if (exception != null) {
+ str += (" with exception " + exception);
+ }
+ return str;
+ }
+
+ /**
+ * Dump the details of this ErrorItem to System.out.
+ */
+ public void dump() {
+ dump(System.out);
+ }
+
+ /**
+ * Dump the details of this ErrorItem on the specified {@link PrintStream}.
+ * @param ps print stream.
+ */
+ public void dump(final PrintStream ps) {
+ String str =
+ "Reported error: \"" + message + "\"";
+
+ if (lineNumber != -1) {
+ str += " at line " + lineNumber + " column " + colNumber;
+ }
+ ps.println(str);
+
+ if (exception != null) {
+ exception.printStackTrace(ps);
+ }
+ }
+}
diff --git a/src/main/java/org/apache/log4j/spi/Log4JULogger.java b/src/main/java/org/apache/log4j/spi/Log4JULogger.java
new file mode 100644
index 0000000..2476810
--- /dev/null
+++ b/src/main/java/org/apache/log4j/spi/Log4JULogger.java
@@ -0,0 +1,229 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.log4j.spi;
+
+import org.apache.log4j.Logger;
+import org.apache.log4j.ULogger;
+import org.apache.log4j.helpers.MessageFormatter;
+import org.apache.log4j.Level;
+
+
+/**
+ * An implementation of ULogger on org.apache.log4j.Logger.
+ */
+public final class Log4JULogger implements ULogger {
+
+ /**
+ * Wrapped log4j logger.
+ */
+ private final Logger logger;
+
+ /**
+ * Create a new instance.
+ *
+ * @param l logger, may not be null.
+ */
+ public Log4JULogger(final Logger l) {
+ super();
+ if (l == null) {
+ throw new NullPointerException("l");
+ }
+ logger = l;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isDebugEnabled() {
+ return logger.isDebugEnabled();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final Object msg) {
+ logger.debug(msg);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final Object parameterizedMsg,
+ final Object param1) {
+ if (logger.isDebugEnabled()) {
+ logger.debug(MessageFormatter.format(
+ parameterizedMsg.toString(), param1));
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ if (logger.isDebugEnabled()) {
+ logger.debug(MessageFormatter.format(
+ parameterizedMsg.toString(), param1, param2));
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final Object msg,
+ final Throwable t) {
+ logger.debug(msg, t);
+ }
+
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isInfoEnabled() {
+ return logger.isInfoEnabled();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final Object msg) {
+ logger.info(msg);
+ }
+
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final Object parameterizedMsg,
+ final Object param1) {
+ if (logger.isInfoEnabled()) {
+ logger.info(MessageFormatter.format(
+ parameterizedMsg.toString(), param1));
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ if (logger.isInfoEnabled()) {
+ logger.info(MessageFormatter.format(
+ parameterizedMsg.toString(),
+ param1,
+ param2));
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final Object msg, final Throwable t) {
+ logger.info(msg, t);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isWarnEnabled() {
+ return logger.isEnabledFor(Level.WARN);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final Object msg) {
+ logger.warn(msg);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final Object parameterizedMsg,
+ final Object param1) {
+ if (logger.isEnabledFor(Level.WARN)) {
+ logger.warn(MessageFormatter.format(
+ parameterizedMsg.toString(), param1));
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ if (logger.isEnabledFor(Level.WARN)) {
+ logger.warn(MessageFormatter.format(
+ parameterizedMsg.toString(), param1, param2));
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final Object msg, final Throwable t) {
+ logger.warn(msg, t);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isErrorEnabled() {
+ return logger.isEnabledFor(Level.ERROR);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final Object msg) {
+ logger.error(msg);
+ }
+
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final Object parameterizedMsg, final Object param1) {
+ if (logger.isEnabledFor(Level.ERROR)) {
+ logger.error(MessageFormatter.format(
+ parameterizedMsg.toString(), param1));
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ if (logger.isEnabledFor(Level.ERROR)) {
+ logger.error(MessageFormatter.format(
+ parameterizedMsg.toString(), param1, param2));
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final Object msg, final Throwable t) {
+ logger.error(msg, t);
+ }
+
+}
diff --git a/src/main/java/org/apache/log4j/spi/LoggerEventListener.java b/src/main/java/org/apache/log4j/spi/LoggerEventListener.java
new file mode 100644
index 0000000..274ea8f
--- /dev/null
+++ b/src/main/java/org/apache/log4j/spi/LoggerEventListener.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.log4j.spi;
+
+import org.apache.log4j.Appender;
+import org.apache.log4j.Logger;
+
+
+/**
+ Interface used to listen for {@link Logger} related events such as
+ add/remove appender or changing levels. Clients register an instance of
+ the interface and the instance is called back when the various events occur.
+
+ {@link LoggerRepository} provides methods for adding and removing
+ LoggerEventListener instances.
+
+ When implementing the methods of this interface, it is useful to remember
+ that the Logger can access the repository using its getRepository()
+ method.
+
+ @author Ceki Gülcü
+ @author Mark Womack
+ @since 1.3
+*/
+public interface LoggerEventListener {
+ /**
+ Called when an appender is added to the logger.
+
+ @param logger The logger to which the appender was added.
+ @param appender The appender added to the logger. */
+ void appenderAddedEvent(Logger logger, Appender appender);
+
+ /**
+ Called when an appender is removed from the logger.
+
+ @param logger The logger from which the appender was removed.
+ @param appender The appender removed from the logger. */
+ void appenderRemovedEvent(Logger logger, Appender appender);
+
+ /**
+ Called when level changed on the logger.
+
+ @param logger The logger that changed levels. */
+ void levelChangedEvent(Logger logger);
+}
diff --git a/src/main/java/org/apache/log4j/spi/LoggerRepositoryEventListener.java b/src/main/java/org/apache/log4j/spi/LoggerRepositoryEventListener.java
new file mode 100644
index 0000000..09d4d78
--- /dev/null
+++ b/src/main/java/org/apache/log4j/spi/LoggerRepositoryEventListener.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.log4j.spi;
+
+
+/**
+ Interface used to listen for {@link LoggerRepository} related
+ events such as startup, reset, and shutdown. Clients register
+ an instance of the interface and the instance is called back
+ when the various events occur.
+
+ {@link LoggerRepository} provides methods for adding and removing
+ LoggerEventListener instances.
+
+ @author Ceki Gülcü
+ @author Mark Womack
+ @since 1.3
+*/
+public interface LoggerRepositoryEventListener {
+ /**
+ Called when the repository configuration is reset.
+ @param repository repository
+ */
+ void configurationResetEvent(LoggerRepository repository);
+
+ /**
+ Called when the repository configuration is changed.
+ @param repository repository
+ */
+ void configurationChangedEvent(LoggerRepository repository);
+
+ /**
+ Called when the repository is shutdown. When this method is
+ invoked, the repository is still valid (ie it has not been
+ shutdown, but will be after this method returns).
+ @param repository repository.
+ */
+ void shutdownEvent(LoggerRepository repository);
+}
diff --git a/src/main/java/org/apache/log4j/spi/LoggerRepositoryEx.java b/src/main/java/org/apache/log4j/spi/LoggerRepositoryEx.java
new file mode 100644
index 0000000..3374a66
--- /dev/null
+++ b/src/main/java/org/apache/log4j/spi/LoggerRepositoryEx.java
@@ -0,0 +1,210 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.log4j.spi;
+
+import org.apache.log4j.Appender;
+import org.apache.log4j.Category;
+import org.apache.log4j.Logger;
+import org.apache.log4j.plugins.PluginRegistry;
+import org.apache.log4j.scheduler.Scheduler;
+
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ A <code>LoggerRepository</code> is used to create and retrieve
+ <code>Loggers</code>. The relation between loggers in a repository
+ depends on the repository but typically loggers are arranged in a
+ named hierarchy.
+
+ <p>In addition to the creational methods, a
+ <code>LoggerRepository</code> can be queried for existing loggers,
+ can act as a point of registry for events related to loggers.
+
+ @author Ceki Gülcü
+ @author Mark Womack
+ @author Curt Arnold
+ @since 1.3 */
+public interface LoggerRepositoryEx extends LoggerRepository {
+ /**
+ Add a {@link LoggerRepositoryEventListener} to the repository. The
+ listener will be called when repository events occur.
+ @param listener event listener, may not be null.
+ @since 1.3*/
+ void addLoggerRepositoryEventListener(
+ LoggerRepositoryEventListener listener);
+
+ /**
+ Remove a {@link LoggerRepositoryEventListener} from the repository.
+ @param listener listener.
+ @since 1.3*/
+ void removeLoggerRepositoryEventListener(
+ LoggerRepositoryEventListener listener);
+
+ /**
+ Add a {@link LoggerEventListener} to the repository. The listener
+ will be called when repository events occur.
+ @param listener listener, may not be null.
+ @since 1.3*/
+ void addLoggerEventListener(LoggerEventListener listener);
+
+ /**
+ Remove a {@link LoggerEventListener} from the repository.
+ @param listener listener, may not be null.
+ @since 1.3*/
+ void removeLoggerEventListener(LoggerEventListener listener);
+
+ /**
+ * Get the name of this logger repository.
+ * @return name, may not be null.
+ * @since 1.3
+ */
+ String getName();
+
+ /**
+ * A logger repository is a named entity.
+ * @param repoName new name, may not be null.
+ * @since 1.3
+ */
+ void setName(String repoName);
+
+ /**
+ * Is the current configuration of the repository in its original (pristine)
+ * state?
+ * @return true if repository is in original state.
+ *
+ * @since 1.3
+ */
+ boolean isPristine();
+
+ /**
+ * Set the pristine flag.
+ * @param state state
+ * @see #isPristine
+ * @since 1.3
+ */
+ void setPristine(boolean state);
+
+ /**
+ Requests that a appender removed event be sent to any registered
+ {@link LoggerEventListener}.
+ @param logger The logger from which the appender was removed.
+ @param appender The appender removed from the logger.
+ @since 1.3*/
+ void fireRemoveAppenderEvent(Category logger, Appender appender);
+
+ /**
+ Requests that a level changed event be sent to any registered
+ {@link LoggerEventListener}.
+ @param logger The logger which changed levels.
+ @since 1.3*/
+ void fireLevelChangedEvent(Logger logger);
+
+ /**
+ Requests that a configuration changed event be sent to any registered
+ {@link LoggerRepositoryEventListener}.
+ @since 1.3*/
+ void fireConfigurationChangedEvent();
+
+ /**
+ * Return the PluginRegisty for this LoggerRepository.
+ * @return plug in registry.
+ * @since 1.3
+ */
+ PluginRegistry getPluginRegistry();
+
+ /**
+ * Return the {@link Scheduler} for this LoggerRepository.
+ * @return scheduler.
+ * @since 1.3
+ */
+ Scheduler getScheduler();
+
+ /**
+ * Get the properties specific for this repository.
+ * @return property map.
+ * @since 1.3
+ */
+ Map getProperties();
+
+ /**
+ * Get the property of this repository.
+ * @param key property key.
+ * @return key value or null if not set.
+ * @since 1.3
+ */
+ String getProperty(String key);
+
+ /**
+ * Set a property of this repository.
+ * @param key key, may not be null.
+ * @param value new value, if null, property will be removed.
+ * @since 1.3
+ */
+ void setProperty(String key, String value);
+
+ /**
+ * Errors which cannot be logged, go to the error list.
+ *
+ * @return List
+ */
+ List getErrorList();
+
+ /**
+ * Errors which cannot be logged, go to the error list.
+ *
+ * @param errorItem an ErrorItem to add to the error list
+ */
+ void addErrorItem(ErrorItem errorItem);
+
+ /**
+ * A LoggerRepository can also act as a store for various objects used
+ * by log4j components.
+ *
+ * @param key key, may not be null.
+ * @return The object stored under 'key'.
+ * @since 1.3
+ */
+ Object getObject(String key);
+
+ /**
+ * Store an object under 'key'. If no object can be found, null is returned.
+ *
+ * @param key key, may not be null.
+ * @param value value, may be null.
+ */
+ void putObject(String key, Object value);
+
+ /**
+ * Sets the logger factory used by {@link LoggerRepository#getLogger(String)}.
+ * @param loggerFactory factory to use, may not be null
+ * @since 1.3
+ */
+ void setLoggerFactory(LoggerFactory loggerFactory);
+
+ /**
+ * Returns the logger factory used by
+ * {@link LoggerRepository#getLogger(String)}.
+ *
+ * @return non-null factory
+ * @since 1.3
+ */
+ LoggerFactory getLoggerFactory();
+
+}
diff --git a/src/main/java/org/apache/log4j/spi/NOPULogger.java b/src/main/java/org/apache/log4j/spi/NOPULogger.java
new file mode 100644
index 0000000..98fe537
--- /dev/null
+++ b/src/main/java/org/apache/log4j/spi/NOPULogger.java
@@ -0,0 +1,200 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.log4j.spi;
+
+import org.apache.log4j.ULogger;
+
+
+/**
+ * A no operation (NOP) implementation of {@link ULogger}.
+ *
+ * @author Ceki Gülcü
+ */
+public final class NOPULogger implements ULogger {
+
+ /**
+ * The unique instance of NOPLogger.
+ */
+ public static final NOPULogger NOP_LOGGER = new NOPULogger();
+
+ /**
+ * There is no point in people creating multiple instances of NullLogger.
+ * Hence, the private access modifier.
+ */
+ private NOPULogger() {
+ super();
+ }
+
+ /**
+ * Get instance.
+ * @param name logger name.
+ * @return logger.
+ */
+ public static NOPULogger getLogger(final String name) {
+ return NOP_LOGGER;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isDebugEnabled() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final Object msg) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final Object parameterizedMsg, final Object param1) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final Object msg, final Throwable t) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isInfoEnabled() {
+ // NOP
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final Object msg) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final Object parameterizedMsg, final Object param1) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final String parameterizedMsg,
+ final Object param1, final Object param2) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final Object msg, final Throwable t) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isWarnEnabled() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final Object msg) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final Object parameterizedMsg,
+ final Object param1) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final Object msg, final Throwable t) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isErrorEnabled() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final Object msg) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final Object parameterizedMsg, final Object param1) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final Object msg, final Throwable t) {
+ // NOP
+ }
+
+}
diff --git a/src/main/java/org/apache/log4j/spi/SimpleULogger.java b/src/main/java/org/apache/log4j/spi/SimpleULogger.java
new file mode 100644
index 0000000..714a57a
--- /dev/null
+++ b/src/main/java/org/apache/log4j/spi/SimpleULogger.java
@@ -0,0 +1,305 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.log4j.spi;
+
+import org.apache.log4j.ULogger;
+import org.apache.log4j.helpers.MessageFormatter;
+
+
+/**
+ * A simple implementation that logs messages of level INFO or higher on
+ * the console (<code>System.out</code>).
+ * <p>
+ * The output includes the relative time in milliseconds, thread name, 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.
+ * <pre>
+176 [main] INFO examples.Sort - Populating an array of 2 elements in reverse.
+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 msg.
+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.
+</pre>
+ *
+ * @author Ceki Gülcü
+ */
+public final class SimpleULogger implements ULogger {
+
+ /**
+ * Logger name.
+ */
+ private final String loggerName;
+
+
+ /**
+ * Mark the time when this class gets loaded into memory.
+ */
+ private static long startTime = System.currentTimeMillis();
+
+ /**
+ * Line separator.
+ */
+ public static final String LINE_SEPARATOR
+ = System.getProperty("line.separator");
+
+ /**
+ * INFO string literal.
+ */
+ private static final String INFO_STR = "INFO";
+ /**
+ * WARN string literal.
+ */
+ private static final String WARN_STR = "WARN";
+ /**
+ * ERROR string literal.
+ */
+ private static final String ERROR_STR = "ERROR";
+
+ /**
+ * Constructor is private to force construction through getLogger.
+ * @param name logger name
+ */
+ private SimpleULogger(final String name) {
+ super();
+ this.loggerName = name;
+ }
+
+ /**
+ * Creates a new instance.
+ *
+ * @param name logger name
+ * @return logger.
+ */
+ public static SimpleULogger getLogger(final String name) {
+ return new SimpleULogger(name);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isDebugEnabled() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final Object msg) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final Object parameterizedMsg, final Object param1) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ // NOP
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void debug(final Object msg, final Throwable t) {
+ // NOP
+ }
+
+ /**
+ * This is our internal implementation for logging regular (non-parameterized)
+ * log messages.
+ *
+ * @param level level
+ * @param message message
+ * @param t throwable
+ */
+ private void log(final String level,
+ final String message,
+ final 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 level
+ * @param parameterizedMsg message pattern
+ * @param param1 param1
+ * @param param2 param2
+ */
+ private void parameterizedLog(final String level,
+ final Object parameterizedMsg,
+ final Object param1,
+ final 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);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isInfoEnabled() {
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final Object msg) {
+ log(INFO_STR, msg.toString(), null);
+ }
+
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final Object parameterizedMsg, final Object param1) {
+ parameterizedLog(INFO_STR, parameterizedMsg, param1, null);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ parameterizedLog(INFO_STR, parameterizedMsg, param1, param2);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void info(final Object msg, final Throwable t) {
+ log(INFO_STR, msg.toString(), t);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isWarnEnabled() {
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final Object msg) {
+ log(WARN_STR, msg.toString(), null);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final Object parameterizedMsg, final Object param1) {
+ parameterizedLog(WARN_STR, parameterizedMsg, param1, null);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ parameterizedLog(WARN_STR, parameterizedMsg, param1, param2);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void warn(final Object msg, final Throwable t) {
+ log(WARN_STR, msg.toString(), t);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isErrorEnabled() {
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final Object msg) {
+ log(ERROR_STR, msg.toString(), null);
+ }
+
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final Object parameterizedMsg, final Object param1) {
+ parameterizedLog(ERROR_STR, parameterizedMsg, param1, null);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final String parameterizedMsg,
+ final Object param1,
+ final Object param2) {
+ parameterizedLog(ERROR_STR, parameterizedMsg, param1, param2);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void error(final Object msg, final Throwable t) {
+ log(ERROR_STR, msg.toString(), t);
+ }
+
+}
diff --git a/src/main/java/org/apache/log4j/spi/Thresholdable.java b/src/main/java/org/apache/log4j/spi/Thresholdable.java
new file mode 100644
index 0000000..bd8e1f4
--- /dev/null
+++ b/src/main/java/org/apache/log4j/spi/Thresholdable.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.log4j.spi;
+
+import org.apache.log4j.Level;
+
+/**
+ * An interface that defines the required methods for supporting the
+ * setting and getting of a level threshold. Components should implement
+ * this interface if logging events they process should meet a certain
+ * threshold before being processed further. Examples of this are
+ * Appenders and Receivers which will not process logging events unless
+ * the event level is at or greater than a set threshold level.
+ *
+ * @author Paul Smith (psmith@apache.org)
+ * @author Mark Womack
+ * @since 1.3
+ */
+public interface Thresholdable {
+ /**
+ * Sets the component theshold to the given level.
+ *
+ * @param level The threshold level events must equal or be greater
+ * than before further processing can be done.
+ */
+ void setThreshold(Level level);
+
+ /**
+ * Gets the current threshold setting of the component.
+ *
+ * @return Level The current threshold level of the component.
+ */
+ Level getThreshold();
+
+ /**
+ * Returns true if the given level is equals or greater than the current
+ * threshold value of the component.
+ *
+ * @param level The level to test against the component threshold.
+ * @return boolean True if level is equal or greater than the
+ * component threshold.
+ */
+ boolean isAsSevereAsThreshold(Level level);
+}
