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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of pax-logging-api Show documentation
The Pax Logging API Library is to allow for the Pax Logging Service to be reloaded without stopping the many dependent bundles. It also contains the OSGi Log Service API and the Knopflerfish Log API.
There is a newer version: 2.2.7
Show newest version
/*
 * 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;
    }

}