0
        } 
    } 
 
    public void logp(Level level, String sourceClass, String sourceMethod, String msg) {
        if (isLoggable(level)) {
            LogRecord lr = new LogRecord(level, msg);
            lr.setSourceClassName(sourceClass);
            lr.setSourceMethodName(sourceMethod);
            doLog(lr);
        } 
    } 
 
    public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object param1) {
        if (isLoggable(level)) {
            LogRecord lr = new LogRecord(level, msg);
            lr.setSourceClassName(sourceClass);
            lr.setSourceMethodName(sourceMethod);
            Object params[] = {param1 };
            lr.setParameters(params);
            doLog(lr);
        } 
    } 
 
    public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object params[]) {
        if (isLoggable(level)) {
            LogRecord lr = new LogRecord(level, msg);
            lr.setSourceClassName(sourceClass);
            lr.setSourceMethodName(sourceMethod);
            lr.setParameters(params);
            doLog(lr);
        } 
    } 
 
    public void logp(Level level, String sourceClass, String sourceMethod, String msg, Throwable thrown) {
        if (isLoggable(level)) {
            LogRecord lr = new LogRecord(level, msg);
            lr.setSourceClassName(sourceClass);
            lr.setSourceMethodName(sourceMethod);
            lr.setThrown(thrown);
            doLog(lr);
        } 
    } 
 
    public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg) {
        if (isLoggable(level)) {
            LogRecord lr = new LogRecord(level, msg);
            lr.setSourceClassName(sourceClass);
            lr.setSourceMethodName(sourceMethod);
            doLog(lr, bundleName);
        } 
    } 
 
    public void logrb(Level level, String sourceClass, String sourceMethod, 
                      String bundleName, String msg, Object param1) {
        if (isLoggable(level)) {
            LogRecord lr = new LogRecord(level, msg);
            lr.setSourceClassName(sourceClass);
            lr.setSourceMethodName(sourceMethod);
            Object params[] = {param1 };
            lr.setParameters(params);
            doLog(lr, bundleName);
        } 
    } 
 
    public void logrb(Level level, String sourceClass, String sourceMethod, 
                      String bundleName, String msg, Object params[]) {
        if (isLoggable(level)) {
            LogRecord lr = new LogRecord(level, msg);
            lr.setSourceClassName(sourceClass);
            lr.setSourceMethodName(sourceMethod);
            lr.setParameters(params);
            doLog(lr, bundleName);
        } 
    } 
 
    public void logrb(Level level, String sourceClass, String sourceMethod, 
                      String bundleName, String msg, Throwable thrown) {
        if (isLoggable(level)) {
            LogRecord lr = new LogRecord(level, msg);
            lr.setSourceClassName(sourceClass);
            lr.setSourceMethodName(sourceMethod);
            lr.setThrown(thrown);
            doLog(lr, bundleName);
        } 
    } 
 
    public void entering(String sourceClass, String sourceMethod) {
        if (isLoggable(Level.FINER)) {
            logp(Level.FINER, sourceClass, sourceMethod, "ENTRY");
        } 
    } 
 
    public void entering(String sourceClass, String sourceMethod, Object param1) {
        if (isLoggable(Level.FINER)) {
            Object params[] = {param1 };
            logp(Level.FINER, sourceClass, sourceMethod, "ENTRY {0}", params);
        } 
    } 
 
    public void entering(String sourceClass, String sourceMethod, Object params[]) {
        if (isLoggable(Level.FINER)) {
            String msg = "ENTRY";
            if (params == null) {
                logp(Level.FINER, sourceClass, sourceMethod, msg);
                return; 
            } 
            StringBuilder builder = new StringBuilder(msg);
            for (int i = 0; i < params.length; i++) {
                builder.append(" {");
                builder.append(Integer.toString(i));
                builder.append("}");
            } 
            logp(Level.FINER, sourceClass, sourceMethod, builder.toString(), params);
        } 
    } 
 
    public void exiting(String sourceClass, String sourceMethod) {
        if (isLoggable(Level.FINER)) {
            logp(Level.FINER, sourceClass, sourceMethod, "RETURN");
        } 
    } 
 
    public void exiting(String sourceClass, String sourceMethod, Object result) {
        if (isLoggable(Level.FINER)) {
            Object params[] = {result };
            logp(Level.FINER, sourceClass, sourceMethod, "RETURN {0}", params);
        } 
    } 
 
    public void throwing(String sourceClass, String sourceMethod, Throwable thrown) {
        if (isLoggable(Level.FINER)) {
            LogRecord lr = new LogRecord(Level.FINER, "THROW");
            lr.setSourceClassName(sourceClass);
            lr.setSourceMethodName(sourceMethod);
            lr.setThrown(thrown);
            doLog(lr);
        } 
    } 
 
    public void severe(String msg) {
        if (isLoggable(Level.SEVERE)) {
            LogRecord lr = new LogRecord(Level.SEVERE, msg);
            doLog(lr);
        } 
    } 
 
    public void warning(String msg) {
        if (isLoggable(Level.WARNING)) {
            LogRecord lr = new LogRecord(Level.WARNING, msg);
            doLog(lr);
        } 
    } 
 
    public void info(String msg) {
        if (isLoggable(Level.INFO)) {
            LogRecord lr = new LogRecord(Level.INFO, msg);
            doLog(lr);
        } 
    } 
 
    public void config(String msg) {
        if (isLoggable(Level.CONFIG)) {
            LogRecord lr = new LogRecord(Level.CONFIG, msg);
            doLog(lr);
        } 
    } 
 
    public void fine(String msg) {
        if (isLoggable(Level.FINE)) {
            LogRecord lr = new LogRecord(Level.FINE, msg);
            doLog(lr);
        } 
    } 
 
    public void finer(String msg) {
        if (isLoggable(Level.FINER)) {
            LogRecord lr = new LogRecord(Level.FINER, msg);
            doLog(lr);
        } 
    } 
 
    public void finest(String msg) {
        if (isLoggable(Level.FINEST)) {
            LogRecord lr = new LogRecord(Level.FINEST, msg);
            doLog(lr);
        } 
    } 
 
    public void setLevel(Level newLevel) throws SecurityException {
        throw new UnsupportedOperationException();
    } 
 
    public abstract Level getLevel();
 
    public boolean isLoggable(Level level) {
        Level l = getLevel();
        return level.intValue() >= l.intValue() && l != Level.OFF;
    } 
 
    protected boolean supportsHandlers() { 
        return false; 
    } 
     
    public synchronized void addHandler(Handler handler) throws SecurityException {
        if (supportsHandlers()) { 
            super.addHandler(handler);
            return; 
        } 
        throw new UnsupportedOperationException();
    } 
 
    public synchronized void removeHandler(Handler handler) throws SecurityException {
        if (supportsHandlers()) { 
            super.removeHandler(handler);
            return; 
        } 
        throw new UnsupportedOperationException();
    } 
 
    public synchronized Handler[] getHandlers() {
        if (supportsHandlers()) { 
            return super.getHandlers(); 
        } 
        throw new UnsupportedOperationException();
    } 
 
    public synchronized void setUseParentHandlers(boolean useParentHandlers) {
        if (supportsHandlers()) { 
            super.setUseParentHandlers(useParentHandlers);
            return; 
        } 
        throw new UnsupportedOperationException();
    } 
 
    public synchronized boolean getUseParentHandlers() { 
        if (supportsHandlers()) { 
            return super.getUseParentHandlers(); 
        } 
        throw new UnsupportedOperationException();
    } 
 
    public Logger getParent() {
        return null; 
    } 
 
    public void setParent(Logger parent) {
        throw new UnsupportedOperationException();
    } 
 
    protected void doLog(LogRecord lr) {
        lr.setLoggerName(getName());
        String rbname = getResourceBundleName();
        if (rbname != null) {
            lr.setResourceBundleName(rbname);
            lr.setResourceBundle(getResourceBundle());
        } 
        internalLog(lr);
    } 
 
    protected void doLog(LogRecord lr, String rbname) {
        lr.setLoggerName(getName());
        if (rbname != null) {
            lr.setResourceBundleName(rbname);
            lr.setResourceBundle(loadResourceBundle(rbname));
        } 
        internalLog(lr);
    } 
 
    protected void internalLog(LogRecord record) {
        Filter filter = getFilter();
        if (filter != null && !filter.isLoggable(record)) {
            return; 
        } 
        String msg = formatMessage(record);
        internalLogFormatted(msg, record);
    } 
 
    protected abstract void internalLogFormatted(String msg, LogRecord record);
 
    protected String formatMessage(LogRecord record) {