[Aglets-commits] aglets2.1/src/org/aglets/log/log4j Log4jInitializer.java,NONE,1.1 Log4jCategory.java,NONE,1.1 Log4jCategory.class,NONE,1.1 Log4jInitializer.class,NONE,1.1

[Luca F. <cat...@us...>]

Update of /cvsroot/aglets/aglets2.1/src/org/aglets/log/log4j
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv7551/src/org/aglets/log/log4j

Added Files:
	Log4jInitializer.java Log4jCategory.java Log4jCategory.class 
	Log4jInitializer.class 
Log Message:


--- NEW FILE: Log4jCategory.java ---
package org.aglets.log.log4j;

import org.apache.log4j.Category;
import org.apache.log4j.Priority;
import org.aglets.log.LogCategory;

/**
 * Wrapper class for log4j implementation of logging
 * category.
 */
public class Log4jCategory implements LogCategory {
    
    // Delegate reference.
    private Category m_category = null;
    
    private final String fullClassName = "org.aglets.log.log4j.Log4jCategory";
    
    public Log4jCategory(String name) {
        m_category = Category.getInstance( name );
    }
    
    /**
     * Logs a message at Fatal priority.
     */
    public void fatal(Object msg) {
        m_category.log(fullClassName, Priority.FATAL, msg, null);
    }
    
     /**
     *  Logs a message at error priority.
     *
     * @param  msg  Message to be logged.
     * @since       1.0
     */
    public void error(Object msg) {
        m_category.log(fullClassName, Priority.ERROR, msg, null);
    }

    
    

    /**
     *  Logs a message at error priority and passes an exception for logging.
     *
     * @param  msg  Message to be logged.
     * @param  exc  Description of Parameter
     * @since       1.0
     */
    public void error(Object msg, Exception exc) {
        m_category.log(fullClassName, Priority.ERROR, msg, exc);
    }


    /**
     *  Logs a message at warn priority.
     *
     * @param  msg  Message to be logged.
     * @since       1.0
     */
    public void warn(Object msg) {
        m_category.log(fullClassName, Priority.WARN, msg, null);
    }


    /**
     *  Logs a mesasge at info priority.
     *
     * @param  msg  Message to be logged.
     * @since       1.0
     */
    public void info(Object msg) {
        m_category.log(fullClassName, Priority.INFO, msg, null);
    }


    /**
     *  Logs a message at debug priority.
     *
     * @param  msg  Message to be logged.
     * @since       1.0
     */
    public void debug(Object msg) {
        m_category.log(fullClassName, Priority.DEBUG, msg, null);
    }
    
    /**
    *  Check whether this category is enabled for the <code>DEBUG</code>
    *  priority.
    *  
    *  <p> This function is intended to lessen the computational cost of
    *  disabled log debug statements.
    * 
    *  <p> For some <code>cat</code> Category object, when you write,
    *  <pre>
    *      cat.debug("This is entry number: " + i );
    *  </pre>
    *  
    *  <p>You incur the cost constructing the message, concatenatiion in
    *  this case, regardless of whether the message is logged or not.
    * 
    *  <p>If you are worried about speed, then you should write
    *  <pre>
    * 	 if(cat.isDebugEnabled()) { 
    * 	   cat.debug("This is entry number: " + i );
    * 	 }
    *  </pre>
    * 
    *  <p>This way you will not incur the cost of parameter
    *  construction if debugging is disabled for <code>cat</code>. On
    *  the other hand, if the <code>cat</code> is debug enabled, you
    *  will incur the cost of evaluating whether the category is debug
    *  enabled twice. Once in <code>isDebugEnabled</code> and once in
    *  the <code>debug</code>.  This is an insignificant overhead
    *  since evaluating a category takes about 1%% of the time it
    *  takes to actually log.
    * 
    *  @return boolean - <code>true</code> if this category is debug
    *  enabled, <code>false</code> otherwise.
    *   
    */
    public boolean isDebugEnabled() {
        return m_category.isDebugEnabled();
    }
}

--- NEW FILE: Log4jInitializer.class ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Log4jCategory.class ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Log4jInitializer.java ---
package org.aglets.log.log4j;

import org.aglets.log.LogInitializer;
import org.aglets.log.LogCategory;
import java.util.Properties;
import org.apache.log4j.xml.DOMConfigurator;

/**
 * Initializes the Log4J logging system.  Logging
 * system will be initialized staticly using the DOMConfigurater.
 * The configuration file agletslog.xml must be in "aglets.home".
 */
public class Log4jInitializer extends LogInitializer {
    
     static {
        // Set the inherited static member to an instance 
        // of this subclass.  Thus, this getCategoryImpl
        // will be invoked.
        m_instance = new Log4jInitializer();
        
        // Get system properties
		Properties system_props = System.getProperties();

		String FS = system_props.getProperty("file.separator");
		String PS = system_props.getProperty("path.separator");
		        
        // Setup XML configuration of log4J
        String logConfig = system_props.getProperty("aglets.home");
        if( !logConfig.endsWith(FS) ) {
            logConfig = logConfig + FS;
        }
        
        DOMConfigurator.configure(logConfig+"cnf"+FS+"agletslog.xml");
    }
    
    /** 
     * Return the Log4j Implmentation  of  the logging 
     * interface.
     * @param  name The name of the category.
     */
    protected LogCategory getCategoryImpl(String name) {
        return new Log4jCategory(name);
    }
}