Level

/**
 * Logback: the reliable, generic, fast and flexible logging framework.
 * Copyright (C) 1999-2015, QOS.ch. All rights reserved.
 *
 * This program and the accompanying materials are dual-licensed under
 * either the terms of the Eclipse Public License v1.0 as published by
 * the Eclipse Foundation
 *
 *   or (per the licensee's choosing)
 *
 * under the terms of the GNU Lesser General Public License version 2.1
 * as published by the Free Software Foundation.
 */
package ch.qos.logback.classic;

import org.slf4j.event.EventConstants;
import org.slf4j.spi.LocationAwareLogger;

/**
 * Defines the set of levels recognized by logback-classic, that is
 * {@link #OFF}, {@link #ERROR}, {@link #WARN}, {@link #INFO}, {@link #DEBUG},
 * {@link #TRACE} and {@link #ALL}.
 * <p/>
 * The <code>Level</code> class is final and cannot be sub-classed.
 * </p>
 */
public final class Level implements java.io.Serializable {

    private static final long serialVersionUID = -814092767334282137L;

    public static final int OFF_INT = Integer.MAX_VALUE;
    public static final int ERROR_INT = 40000;
    public static final int WARN_INT = 30000;
    public static final int INFO_INT = 20000;
    public static final int DEBUG_INT = 10000;
    public static final int TRACE_INT = 5000;
    public static final int ALL_INT = Integer.MIN_VALUE;

    public static final Integer OFF_INTEGER = OFF_INT;
    public static final Integer ERROR_INTEGER = ERROR_INT;
    public static final Integer WARN_INTEGER = WARN_INT;
    public static final Integer INFO_INTEGER = INFO_INT;
    public static final Integer DEBUG_INTEGER = DEBUG_INT;
    public static final Integer TRACE_INTEGER = TRACE_INT;
    public static final Integer ALL_INTEGER = ALL_INT;

    /**
     * The <code>OFF</code> is used to turn off logging. It is intended to be used
     * for logging system configuration.
     *
     * Warning: it should never be passed as an argument to logger methods
     * in a regular log statement.
     */
    public static final Level OFF = new Level(OFF_INT, "OFF");

    /**
     * The <code>ERROR</code> level designates error events which may or not be
     * fatal to the application.
     */
    public static final Level ERROR = new Level(ERROR_INT, "ERROR");

    /**
     * The <code>WARN</code> level designates potentially harmful situations.
     */
    public static final Level WARN = new Level(WARN_INT, "WARN");

    /**
     * The <code>INFO</code> level designates informational messages highlighting
     * overall progress of the application.
     */
    public static final Level INFO = new Level(INFO_INT, "INFO");

    /**
     * The <code>DEBUG</code> level designates informational events of lower
     * importance.
     */
    public static final Level DEBUG = new Level(DEBUG_INT, "DEBUG");

    /**
     * The <code>TRACE</code> level designates informational events of very low
     * importance.
     */
    public static final Level TRACE = new Level(TRACE_INT, "TRACE");

    /**
     * <p>The <code>ALL</code> is used to turn on all logging. The <code>ALL</code> level is vestigial from
     * log4j 1.x.
     * </p>
     *
     * <p>In logback, where the Level class is final, logging can be turned on for all levels by setting
     * a logger's level to <code>TRACE</code>.
     * </p>
     *
     * <p>Thus, the <code>ALL</code> level is marked as deprecated.
     * </p>
     *
     * @deprecated with no replacement
     */
    public static final Level ALL = new Level(ALL_INT, "ALL");

    public final int levelInt;
    public final String levelStr;

    /**
     * Instantiate a Level object.
     */
    private Level(int levelInt, String levelStr) {
        this.levelInt = levelInt;
        this.levelStr = levelStr;
    }

    /**
     * Returns the string representation of this Level.
     */
    public String toString() {
        return levelStr;
    }

    /**
     * Returns the integer representation of this Level.
     */
    public int toInt() {
        return levelInt;
    }

    static public Level convertAnSLF4JLevel(org.slf4j.event.Level slf4jLevel) {
        final int levelInt = slf4jLevel.toInt();
        return fromLocationAwareLoggerInteger(levelInt);
    }

    /**
     * Convert a Level to an Integer object.
     *
     * @return This level's Integer mapping.
     */
    public Integer toInteger() {
        switch (levelInt) {
        case ALL_INT:
            return ALL_INTEGER;
        case TRACE_INT:
            return TRACE_INTEGER;
        case DEBUG_INT:
            return DEBUG_INTEGER;
        case INFO_INT:
            return INFO_INTEGER;
        case WARN_INT:
            return WARN_INTEGER;
        case ERROR_INT:
            return ERROR_INTEGER;
        case OFF_INT:
            return OFF_INTEGER;
        default:
            throw new IllegalStateException("Level " + levelStr + ", " + levelInt + " is unknown.");
        }
    }

    /**
     * Returns <code>true</code> if this Level has a higher or equal Level than the
     * Level passed as argument, <code>false</code> otherwise.
     */
    public boolean isGreaterOrEqual(Level r) {
        return levelInt >= r.levelInt;
    }

    /**
     * Convert the string passed as argument to a Level. If the conversion fails,
     * then this method returns {@link #DEBUG}.
     */
    public static Level toLevel(String sArg) {
        return toLevel(sArg, Level.DEBUG);
    }

    /**
     * This method exists in order to comply with Joran's valueOf convention.
     *
     * @param sArg
     * @return
     */
    public static Level valueOf(String sArg) {
        return toLevel(sArg, Level.DEBUG);
    }

    /**
     * Convert an integer passed as argument to a Level. If the conversion fails,
     * then this method returns {@link #DEBUG}.
     */
    public static Level toLevel(int val) {
        return toLevel(val, Level.DEBUG);
    }

    /**
     * Convert an integer passed as argument to a Level. If the conversion fails,
     * then this method returns the specified default.
     */
    public static Level toLevel(int val, Level defaultLevel) {
        switch (val) {
        case ALL_INT:
            return ALL;
        case TRACE_INT:
            return TRACE;
        case DEBUG_INT:
            return DEBUG;
        case INFO_INT:
            return INFO;
        case WARN_INT:
            return WARN;
        case ERROR_INT:
            return ERROR;
        case OFF_INT:
            return OFF;
        default:
            return defaultLevel;
        }
    }

    /**
     * Convert the string passed as argument to a Level. If the conversion fails,
     * then this method returns the value of <code>defaultLevel</code>.
     */
    public static Level toLevel(final String sArg, Level defaultLevel) {
        if (sArg == null) {
            return defaultLevel;
        }

        // see LOGBACK-1288
        final String in = sArg.trim();

        if (in.equalsIgnoreCase("ALL")) {
            return Level.ALL;
        }
        if (in.equalsIgnoreCase("TRACE")) {
            return Level.TRACE;
        }
        if (in.equalsIgnoreCase("DEBUG")) {
            return Level.DEBUG;
        }
        if (in.equalsIgnoreCase("INFO")) {
            return Level.INFO;
        }
        if (in.equalsIgnoreCase("WARN")) {
            return Level.WARN;
        }
        if (in.equalsIgnoreCase("ERROR")) {
            return Level.ERROR;
        }
        if (in.equalsIgnoreCase("OFF")) {
            return Level.OFF;
        }
        return defaultLevel;
    }

    /**
     * Return the flyweight instance of the level received through serialization,
     * i.e. 'this'.
     *
     * @return The appropriate flyweight instance
     */
    private Object readResolve() {
        return toLevel(this.levelInt);
    }

    /**
     * Convert one of the integer values defined in {@link LocationAwareLogger}
     * interface to an instance of this class, i.e. a Level.
     *
     * @param levelInt An integer value representing a level as defined in
     *                 LocationAwareLogger
     * @return an instance of this class, i.e. a Level.
     * @since 1.0.1
     */
    public static Level fromLocationAwareLoggerInteger(int levelInt) {
        Level level;
        switch (levelInt) {
        case EventConstants.TRACE_INT:
            level = TRACE;
            break;
        case EventConstants.DEBUG_INT:
            level = DEBUG;
            break;
        case EventConstants.INFO_INT:
            level = INFO;
            break;
        case EventConstants.WARN_INT:
            level = WARN;
            break;
        case EventConstants.ERROR_INT:
            level = ERROR;
            break;
        default:
            throw new IllegalArgumentException(levelInt + " not a valid level value");
        }
        return level;
    }

    /**
     * Convert this level instance to an integer value defined in the
     * {@link LocationAwareLogger} interface.
     *
     * @param level The level to convert to LocationAwareLogger integer
     * @return int An integer corresponding to this level as defined in
     *         LocationAwareLogger
     * @since 1.0.1
     */
    public static int toLocationAwareLoggerInteger(Level level) {
        if (level == null)
            throw new IllegalArgumentException("null level parameter is not admitted");
        switch (level.toInt()) {
        case Level.TRACE_INT:
            return EventConstants.TRACE_INT;
        case Level.DEBUG_INT:
            return EventConstants.DEBUG_INT;
        case Level.INFO_INT:
            return EventConstants.INFO_INT;
        case Level.WARN_INT:
            return EventConstants.WARN_INT;
        case Level.ERROR_INT:
            return EventConstants.ERROR_INT;
        default:
            throw new IllegalArgumentException(level + " not a valid level value");
        }
    }
}