/*
* 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.lf5;
import java.awt.*;
import java.util.*;
import java.util.List;
/**
* The LogLevel class defines a set of standard logging levels.
*
* The logging Level objects are ordered and are specified by ordered
* integers. Enabling logging at a given level also enables logging at all
* higher levels.
*
* @author Michael J. Sikorsky
* @author Robert Shaw
* @author Brent Sprecher
* @author Richard Hurst
* @author Brad Marlborough
*/
// Contributed by ThoughtWorks Inc.
public class LogLevel implements java.io.Serializable {
//--------------------------------------------------------------------------
// Constants:
//--------------------------------------------------------------------------
// log4j log levels.
public final static LogLevel FATAL = new LogLevel("FATAL", 0);
public final static LogLevel ERROR = new LogLevel("ERROR", 1);
public final static LogLevel WARN = new LogLevel("WARN", 2);
public final static LogLevel INFO = new LogLevel("INFO", 3);
public final static LogLevel DEBUG = new LogLevel("DEBUG", 4);
// jdk1.4 log levels NOTE: also includes INFO
public final static LogLevel SEVERE = new LogLevel("SEVERE", 1);
public final static LogLevel WARNING = new LogLevel("WARNING", 2);
public final static LogLevel CONFIG = new LogLevel("CONFIG", 4);
public final static LogLevel FINE = new LogLevel("FINE", 5);
public final static LogLevel FINER = new LogLevel("FINER", 6);
public final static LogLevel FINEST = new LogLevel("FINEST", 7);
//--------------------------------------------------------------------------
// Protected Variables:
//--------------------------------------------------------------------------
protected String _label;
protected int _precedence;
//--------------------------------------------------------------------------
// Private Variables:
//--------------------------------------------------------------------------
private static LogLevel[] _log4JLevels;
private static LogLevel[] _jdk14Levels;
private static LogLevel[] _allDefaultLevels;
private static Map _logLevelMap;
private static Map _logLevelColorMap;
private static Map _registeredLogLevelMap = new HashMap();
//--------------------------------------------------------------------------
// Constructors:
//--------------------------------------------------------------------------
static {
_log4JLevels = new LogLevel[]{FATAL, ERROR, WARN, INFO, DEBUG};
_jdk14Levels = new LogLevel[]{SEVERE, WARNING, INFO,
CONFIG, FINE, FINER, FINEST};
_allDefaultLevels = new LogLevel[]{FATAL, ERROR, WARN, INFO, DEBUG,
SEVERE, WARNING, CONFIG, FINE, FINER, FINEST};
_logLevelMap = new HashMap();
for (int i = 0; i < _allDefaultLevels.length; i++) {
_logLevelMap.put(_allDefaultLevels[i].getLabel(), _allDefaultLevels[i]);
}
// prepopulate map with levels and text color of black
_logLevelColorMap = new HashMap();
for (int i = 0; i < _allDefaultLevels.length; i++) {
_logLevelColorMap.put(_allDefaultLevels[i], Color.black);
}
}
public LogLevel(String label, int precedence) {
_label = label;
_precedence = precedence;
}
//--------------------------------------------------------------------------
// Public Methods:
//--------------------------------------------------------------------------
/**
* Return the Label of the LogLevel.
*/
public String getLabel() {
return _label;
}
/**
* Returns true if the level supplied is encompassed by this level.
* For example, LogLevel.SEVERE encompasses no other LogLevels and
* LogLevel.FINE encompasses all other LogLevels. By definition,
* a LogLevel encompasses itself.
*/
public boolean encompasses(LogLevel level) {
if (level.getPrecedence() <= getPrecedence()) {
return true;
}
return false;
}
/**
* Convert a log level label into a LogLevel object.
*
* @param level The label of a level to be converted into a LogLevel.
* @return LogLevel The LogLevel with a label equal to level.
* @throws LogLevelFormatException Is thrown when the level can not be
* converted into a LogLevel.
*/
public static LogLevel valueOf(String level)
throws LogLevelFormatException {
LogLevel logLevel = null;
if (level != null) {
level = level.trim().toUpperCase();
logLevel = (LogLevel) _logLevelMap.get(level);
}
// Didn't match, Check for registered LogLevels
if (logLevel == null && _registeredLogLevelMap.size() > 0) {
logLevel = (LogLevel) _registeredLogLevelMap.get(level);
}
if (logLevel == null) {
StringBuffer buf = new StringBuffer();
buf.append("Error while trying to parse (" + level + ") into");
buf.append(" a LogLevel.");
throw new LogLevelFormatException(buf.toString());
}
return logLevel;
}
/**
* Registers a used defined LogLevel.
*
* @param logLevel The log level to be registered. Cannot be a default LogLevel
* @return LogLevel The replaced log level.
*/
public static LogLevel register(LogLevel logLevel) {
if (logLevel == null) return null;
// ensure that this is not a default log level
if (_logLevelMap.get(logLevel.getLabel()) == null) {
return (LogLevel) _registeredLogLevelMap.put(logLevel.getLabel(), logLevel);
}
return null;
}
public static void register(LogLevel[] logLevels) {
if (logLevels != null) {
for (int i = 0; i < logLevels.length; i++) {
register(logLevels[i]);
}
}
}
public static void register(List logLevels) {
if (logLevels != null) {
Iterator it = logLevels.iterator();
while (it.hasNext()) {
register((LogLevel) it.next());
}
}
}
public boolean equals(Object o) {
boolean equals = false;
if (o instanceof LogLevel) {
if (this.getPrecedence() ==
((LogLevel) o).getPrecedence()) {
equals = true;
}
}
return equals;
}
public int hashCode() {
return _label.hashCode();
}
public String toString() {
return _label;
}
// set a text color for a specific log level
public void setLogLevelColorMap(LogLevel level, Color color) {
// remove the old entry
_logLevelColorMap.remove(level);
// add the new color entry
if (color == null) {
color = Color.black;
}
_logLevelColorMap.put(level, color);
}
public static void resetLogLevelColorMap() {
// empty the map
_logLevelColorMap.clear();
// repopulate map and reset text color black
for (int i = 0; i < _allDefaultLevels.length; i++) {
_logLevelColorMap.put(_allDefaultLevels[i], Color.black);
}
}
/**
* @return A <code>List</code> of <code>LogLevel</code> objects that map
* to log4j <code>Priority</code> objects.
*/
public static List getLog4JLevels() {
return Arrays.asList(_log4JLevels);
}
public static List getJdk14Levels() {
return Arrays.asList(_jdk14Levels);
}
public static List getAllDefaultLevels() {
return Arrays.asList(_allDefaultLevels);
}
public static Map getLogLevelColorMap() {
return _logLevelColorMap;
}
//--------------------------------------------------------------------------
// Protected Methods:
//--------------------------------------------------------------------------
protected int getPrecedence() {
return _precedence;
}
//--------------------------------------------------------------------------
// Private Methods:
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// Nested Top-Level Classes or Interfaces:
//--------------------------------------------------------------------------
}