org.apache.log4j.Level Maven / Gradle / Ivy

Go to download
/*
 * 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.
 */

// Contributors:  Kitching Simon 
//                Nicholas Wolff

package org.apache.log4j;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * Defines the minimum set of levels recognized by the system, that is
 * OFF, FATAL, ERROR,
 * WARN, INFODEBUG and
 * ALL.
 *
 * The Level class may be subclassed to define a larger
 * level set.
 *
 * @author Ceki Gülcü
 */
public class Level extends Priority implements Serializable
{

    /**
     * TRACE level integer value.
     *
     * @since 1.2.12
     */
    public static final int TRACE_INT = 5000;

    /**
     * The OFF has the highest possible rank and is
     * intended to turn off logging.
     */
    final static public Level OFF = new Level( OFF_INT, "OFF", 0 );

    /**
     * The FATAL level designates very severe error
     * events that will presumably lead the application to abort.
     */
    final static public Level FATAL = new Level( FATAL_INT, "FATAL", 0 );

    /**
     * The ERROR level designates error events that
     * might still allow the application to continue running.
     */
    final static public Level ERROR = new Level( ERROR_INT, "ERROR", 3 );

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

    /**
     * The INFO level designates informational messages
     * that highlight the progress of the application at coarse-grained
     * level.
     */
    final static public Level INFO = new Level( INFO_INT, "INFO", 6 );

    /**
     * The DEBUG Level designates fine-grained
     * informational events that are most useful to debug an
     * application.
     */
    final static public Level DEBUG = new Level( DEBUG_INT, "DEBUG", 7 );

    /**
     * The TRACE Level designates finer-grained
     * informational events than the DEBUGALL has the lowest possible rank and is intended to
     * turn on all logging.
     */
    final static public Level ALL = new Level( ALL_INT, "ALL", 7 );

    /**
     * Serialization version id.
     */
    static final long serialVersionUID = 3491141966387921974L;

    /**
     * Instantiate a Level object.
     *
     * @param level            TODO
     * @param levelStr         TODO
     * @param syslogEquivalent TODO
     */
    protected Level( int level, String levelStr, int syslogEquivalent )
    {
        super( level, levelStr, syslogEquivalent );
    }

    /**
     * Convert the string passed as argument to a level. If the
     * conversion fails, then this method returns {@link #DEBUG}.
     *
     * @param sArg TODO
     *
     * @return TODO
     */
    public static Level toLevel( 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}.
     *
     * @param val TODO
     *
     * @return TODO
     */
    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.
     *
     * @param val          TODO
     * @param defaultLevel TODO
     *
     * @return TODO
     */
    public static Level toLevel( int val, Level defaultLevel )
    {
        switch( val )
        {
            case ALL_INT:
                return ALL;
            case DEBUG_INT:
                return Level.DEBUG;
            case INFO_INT:
                return Level.INFO;
            case WARN_INT:
                return Level.WARN;
            case ERROR_INT:
                return Level.ERROR;
            case FATAL_INT:
                return Level.FATAL;
            case OFF_INT:
                return OFF;
            case TRACE_INT:
                return Level.TRACE;
            default:
                return defaultLevel;
        }
    }

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

        String s = sArg.toUpperCase();

        if( s.equals( "ALL" ) )
        {
            return Level.ALL;
        }
        if( s.equals( "DEBUG" ) )
        {
            return Level.DEBUG;
        }
        if( s.equals( "INFO" ) )
        {
            return Level.INFO;
        }
        if( s.equals( "WARN" ) )
        {
            return Level.WARN;
        }
        if( s.equals( "ERROR" ) )
        {
            return Level.ERROR;
        }
        if( s.equals( "FATAL" ) )
        {
            return Level.FATAL;
        }
        if( s.equals( "OFF" ) )
        {
            return Level.OFF;
        }
        if( s.equals( "TRACE" ) )
        {
            return Level.TRACE;
        }
        return defaultLevel;
    }

    /**
     * Custom deserialization of Level.
     *
     * @param s serialization stream.
     *
     * @throws IOException            if IO exception.
     * @throws ClassNotFoundException if class not found.
     */
    private void readObject( final ObjectInputStream s )
        throws IOException, ClassNotFoundException
    {
        s.defaultReadObject();
        level = s.readInt();
        syslogEquivalent = s.readInt();
        levelStr = s.readUTF();
        if( levelStr == null )
        {
            levelStr = "";
        }
    }

    /**
     * Serialize level.
     *
     * @param s serialization stream.
     *
     * @throws IOException if exception during serialization.
     */
    private void writeObject( final ObjectOutputStream s )
        throws IOException
    {
        s.defaultWriteObject();
        s.writeInt( level );
        s.writeInt( syslogEquivalent );
        s.writeUTF( levelStr );
    }

    /**
     * Resolved deserialized level to one of the stock instances.
     * May be overriden in classes derived from Level.
     *
     * @return resolved object.
     */
    private Object readResolve()
    {
        //
        //  if the deserizalized object is exactly an instance of Level
        //
        if( getClass() == Level.class )
        {
            return toLevel( level );
        }
        //
        //   extension of Level can't substitute stock item
        //
        return this;
    }

}