public LogFactoryImpl() 
{
        super();
        initDiagnostics();  // method on this object
        if (isDiagnosticsEnabled()) {
            logDiagnostic("Instance created.");
        }
}

Public no-arguments constructor required by the lookup mechanism.

 public Object getAttribute(String name) 
{
        return (attributes.get(name));
}

Return the configuration attribute with the specified name (if any), or null if there is no such attribute.

 public String[] getAttributeNames() 
{
        Vector names = new Vector();
        Enumeration keys = attributes.keys();
        while (keys.hasMoreElements()) {
            names.addElement((String) keys.nextElement());
        }
        String results[] = new String[names.size()];
        for (int i = 0; i <  results.length; i++) {
            results[i] = (String) names.elementAt(i);
        }
        return (results);
}

Return an array containing the names of all currently defined configuration attributes. If there are no such attributes, a zero length array is returned.

 protected static ClassLoader getClassLoader(Class clazz) 
{
        return LogFactory.getClassLoader(clazz);
}

Workaround for bug in Java1.2; in theory this method is not needed. See LogFactory.getClassLoader.

 protected static ClassLoader getContextClassLoader() throws LogConfigurationException 
{
        return LogFactory.getContextClassLoader();
}

Gets the context classloader. This method is a workaround for a java 1.2 compiler bug.

 public Log getInstance(Class clazz) throws LogConfigurationException 
{
        return (getInstance(clazz.getName()));
}

Convenience method to derive a name from the specified class and call getInstance(String) with it.

 public Log getInstance(String name) throws LogConfigurationException 
{
        Log instance = (Log) instances.get(name);
        if (instance == null) {
            instance = newInstance(name);
            instances.put(name, instance);
        }
        return (instance);
}

Construct (if necessary) and return a Log instance, using the factory's current set of configuration attributes.

NOTE - Depending upon the implementation of the LogFactory you are using, the Log instance you are returned may or may not be local to the current application, and may or may not be returned again on a subsequent call with the same name argument.

 protected String getLogClassName() 
{
        if (logClassName == null) {
            discoverLogImplementation(getClass().getName());
        }
        return logClassName;
}

Return the fully qualified Java classname of the Log implementation we will be using.

 protected Constructor getLogConstructor() throws LogConfigurationException 
{
        // Return the previously identified Constructor (if any)
        if (logConstructor == null) {
            discoverLogImplementation(getClass().getName());
        }
        return logConstructor;
}

Return the Constructor that can be called to instantiate new org.apache.commons.logging.Log instances.

IMPLEMENTATION NOTE - Race conditions caused by calling this method from more than one thread are ignored, because the same Constructor instance will ultimately be derived in all circumstances.

 protected static boolean isDiagnosticsEnabled() 
{
        return LogFactory.isDiagnosticsEnabled();
}

Workaround for bug in Java1.2; in theory this method is not needed. See LogFactory.isDiagnosticsEnabled.

 protected boolean isJdk13LumberjackAvailable() 
{
        return isLogLibraryAvailable(
                "Jdk13Lumberjack",
                "org.apache.commons.logging.impl.Jdk13LumberjackLogger");
}

Is JDK 1.3 with Lumberjack logging available?

 protected boolean isJdk14Available() 
{
        return isLogLibraryAvailable(
                "Jdk14",
                "org.apache.commons.logging.impl.Jdk14Logger");
}

Return true if JDK 1.4 or later logging is available. Also checks that the Throwable class supports getStackTrace(), which is required by Jdk14Logger.

 protected boolean isLog4JAvailable() 
{
        return isLogLibraryAvailable(
                "Log4J",
                LOGGING_IMPL_LOG4J_LOGGER);
}

Is a Log4J implementation available?

 protected  void logDiagnostic(String msg) 
{
        if (isDiagnosticsEnabled()) {
            logRawDiagnostic(diagnosticPrefix + msg);
        }
}

Output a diagnostic message to a user-specified destination (if the user has enabled diagnostic logging).

 protected Log newInstance(String name) throws LogConfigurationException 
{
        Log instance = null;
        try {
            if (logConstructor == null) {
                instance = discoverLogImplementation(name);
            }
            else {
                Object params[] = { name };
                instance = (Log) logConstructor.newInstance(params);
            }
            if (logMethod != null) {
                Object params[] = { this };
                logMethod.invoke(instance, params);
            }
            return (instance);
        } catch (LogConfigurationException lce) {
            // this type of exception means there was a problem in discovery
            // and we've already output diagnostics about the issue, etc.; 
            // just pass it on
            throw (LogConfigurationException) lce;
        } catch (InvocationTargetException e) {
            // A problem occurred invoking the Constructor or Method 
            // previously discovered
            Throwable c = e.getTargetException();
            if (c != null) {
                throw new LogConfigurationException(c);
            } else {
                throw new LogConfigurationException(e);
            }
        } catch (Throwable t) {
            // A problem occurred invoking the Constructor or Method 
            // previously discovered
            throw new LogConfigurationException(t);
        }
}

Create and return a new org.apache.commons.logging.Log instance for the specified name.

 public  void release() 
{
        logDiagnostic("Releasing all known loggers");
        instances.clear();
}

Release any internal references to previously created org.apache.commons.logging.Log instances returned by this factory. This is useful in environments like servlet containers, which implement application reloading by throwing away a ClassLoader. Dangling references to objects in that class loader would prevent garbage collection.

 public  void removeAttribute(String name) 
{
        attributes.remove(name);
}

Remove any configuration attribute associated with the specified name. If there is no such attribute, no action is taken.

 public  void setAttribute(String name,
    Object value) 
{
        if (logConstructor != null) {
            logDiagnostic("setAttribute: call too late; configuration already performed.");
        }
        if (value == null) {
            attributes.remove(name);
        } else {
            attributes.put(name, value);
        }
        if (name.equals(TCCL_KEY)) {
            useTCCL = Boolean.valueOf(value.toString()).booleanValue();
        }
}

Set the configuration attribute with the specified name. Calling this with a null value is equivalent to calling removeAttribute(name).

This method can be used to set logging configuration programmatically rather than via system properties. It can also be used in code running within a container (such as a webapp) to configure behaviour on a per-component level instead of globally as system properties would do. To use this method instead of a system property, call

LogFactory.getFactory().setAttribute(...)

This must be done before the first Log object is created; configuration changes after that point will be ignored.

This method is also called automatically if LogFactory detects a commons-logging.properties file; every entry in that file is set automatically as an attribute here.