}    /**     * <p>Write the content of the message accumulated in the specified     * <code>StringBuffer</code> to the appropriate output destination.  The     * default implementation writes to <code>System.err</code>.</p>     *     * @param buffer A <code>StringBuffer</code> containing the accumulated     *  text to be logged     */    protected void write(StringBuffer buffer) {        System.err.println(buffer.toString());    }    /**     * Is the given log level currently enabled?     *     * @param logLevel is this level enabled?     */    protected boolean isLevelEnabled(int logLevel) {        // log level are numerically ordered so can use simple numeric        // comparison        return (logLevel >= currentLogLevel);    }    // -------------------------------------------------------- Log Implementation    /**     * <p> Log a message with debug log level.</p>     */    public final void debug(Object message) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG)) {            log(SimpleLog.LOG_LEVEL_DEBUG, message, null);        }    }    /**     * <p> Log an error with debug log level.</p>     */    public final void debug(Object message, Throwable t) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG)) {            log(SimpleLog.LOG_LEVEL_DEBUG, message, t);        }    }    /**     * <p> Log a message with trace log level.</p>     */    public final void trace(Object message) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {            log(SimpleLog.LOG_LEVEL_TRACE, message, null);        }    }    /**     * <p> Log an error with trace log level.</p>     */    public final void trace(Object message, Throwable t) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {            log(SimpleLog.LOG_LEVEL_TRACE, message, t);        }    }    /**     * <p> Log a message with info log level.</p>     */    public final void info(Object message) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_INFO)) {            log(SimpleLog.LOG_LEVEL_INFO,message,null);        }    }    /**     * <p> Log an error with info log level.</p>     */    public final void info(Object message, Throwable t) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_INFO)) {            log(SimpleLog.LOG_LEVEL_INFO, message, t);        }    }    /**     * <p> Log a message with warn log level.</p>     */    public final void warn(Object message) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_WARN)) {            log(SimpleLog.LOG_LEVEL_WARN, message, null);        }    }    /**     * <p> Log an error with warn log level.</p>     */    public final void warn(Object message, Throwable t) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_WARN)) {            log(SimpleLog.LOG_LEVEL_WARN, message, t);        }    }    /**     * <p> Log a message with error log level.</p>     */    public final void error(Object message) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR)) {            log(SimpleLog.LOG_LEVEL_ERROR, message, null);        }    }    /**     * <p> Log an error with error log level.</p>     */    public final void error(Object message, Throwable t) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR)) {            log(SimpleLog.LOG_LEVEL_ERROR, message, t);        }    }    /**     * <p> Log a message with fatal log level.</p>     */    public final void fatal(Object message) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL)) {            log(SimpleLog.LOG_LEVEL_FATAL, message, null);        }    }    /**     * <p> Log an error with fatal log level.</p>     */    public final void fatal(Object message, Throwable t) {        if (isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL)) {            log(SimpleLog.LOG_LEVEL_FATAL, message, t);        }    }    /**     * <p> Are debug messages currently enabled? </p>     *     * <p> This allows expensive operations such as <code>String</code>     * concatenation to be avoided when the message will be ignored by the     * logger. </p>     */    public final boolean isDebugEnabled() {        return isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG);    }    /**     * <p> Are error messages currently enabled? </p>     *     * <p> This allows expensive operations such as <code>String</code>     * concatenation to be avoided when the message will be ignored by the     * logger. </p>     */    public final boolean isErrorEnabled() {        return isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR);    }    /**     * <p> Are fatal messages currently enabled? </p>     *     * <p> This allows expensive operations such as <code>String</code>     * concatenation to be avoided when the message will be ignored by the     * logger. </p>     */    public final boolean isFatalEnabled() {        return isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL);    }    /**     * <p> Are info messages currently enabled? </p>     *     * <p> This allows expensive operations such as <code>String</code>     * concatenation to be avoided when the message will be ignored by the     * logger. </p>     */    public final boolean isInfoEnabled() {        return isLevelEnabled(SimpleLog.LOG_LEVEL_INFO);    }    /**     * <p> Are trace messages currently enabled? </p>     *     * <p> This allows expensive operations such as <code>String</code>     * concatenation to be avoided when the message will be ignored by the     * logger. </p>     */    public final boolean isTraceEnabled() {        return isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE);    }    /**     * <p> Are warn messages currently enabled? </p>     *     * <p> This allows expensive operations such as <code>String</code>     * concatenation to be avoided when the message will be ignored by the     * logger. </p>     */    public final boolean isWarnEnabled() {        return isLevelEnabled(SimpleLog.LOG_LEVEL_WARN);    }    /**     * Return the thread context class loader if available.     * Otherwise return null.     *     * The thread context class loader is available for JDK 1.2     * or later, if certain security conditions are met.     *     * @exception LogConfigurationException if a suitable class loader     * cannot be identified.     */    private static ClassLoader getContextClassLoader()    {        ClassLoader classLoader = null;        if (classLoader == null) {            try {                // Are we running on a JDK 1.2 or later system?                Method method = Thread.class.getMethod("getContextClassLoader", null);                // Get the thread context class loader (if there is one)                try {                    classLoader = (ClassLoader)method.invoke(Thread.currentThread(), null);                } catch (IllegalAccessException e) {                    ;  // ignore                } catch (InvocationTargetException e) {                    /**                     * InvocationTargetException is thrown by 'invoke' when                     * the method being invoked (getContextClassLoader) throws                     * an exception.                     *                     * getContextClassLoader() throws SecurityException when                     * the context class loader isn't an ancestor of the                     * calling class's class loader, or if security                     * permissions are restricted.                     *                     * In the first case (not related), we want to ignore and                     * keep going.  We cannot help but also ignore the second                     * with the logic below, but other calls elsewhere (to                     * obtain a class loader) will trigger this exception where                     * we can make a distinction.                     */                    if (e.getTargetException() instanceof SecurityException) {                        ;  // ignore                    } else {                        // Capture 'e.getTargetException()' exception for details                        // alternate: log 'e.getTargetException()', and pass back 'e'.                        throw new LogConfigurationException                            ("Unexpected InvocationTargetException", e.getTargetException());                    }                }            } catch (NoSuchMethodException e) {                // Assume we are running on JDK 1.1                ;  // ignore            }        }        if (classLoader == null) {            classLoader = SimpleLog.class.getClassLoader();        }        // Return the selected class loader        return classLoader;    }    private static InputStream getResourceAsStream(final String name)    {        return (InputStream)AccessController.doPrivileged(            new PrivilegedAction() {                public Object run() {                    ClassLoader threadCL = getContextClassLoader();                    if (threadCL != null) {                        return threadCL.getResourceAsStream(name);                    } else {                        return ClassLoader.getSystemResourceAsStream(name);                    }                }            });    }}