protected Handler() 
{

}

Default constructor. The resulting Handler has a log level of Level.ALL, no Formatter, and no Filter. A default ErrorManager instance is installed as the ErrorManager.

  void checkAccess() throws SecurityException 
{
        if (sealed) {
            manager.checkAccess();
        }
}

 abstract public  void close() throws SecurityException
Close the Handler and free all associated resources.

The close method will perform a flush and then close the
Handler. After close has been called this Handler
should no longer be used. Method calls may either be silently
ignored or may throw runtime exceptions.

 abstract public  void flush()
Flush any buffered output.

 public String getEncoding() 
{
        return encoding;
}

Return the character encoding for this Handler.

 public ErrorManager getErrorManager() 
{
        checkAccess();
        return errorManager;
}

Retrieves the ErrorManager for this Handler.

 public Filter getFilter() 
{
        return filter;
}

Get the current Filter for this Handler.

 public Formatter getFormatter() 
{
        return formatter;
}

Return the Formatter for this Handler.

 public synchronized Level getLevel() 
{
        return logLevel;
}

Get the log level specifying which messages will be logged by this Handler. Message levels lower than this level will be discarded.

 public boolean isLoggable(LogRecord record) 
{
        int levelValue = getLevel().intValue();
        if (record.getLevel().intValue() <  levelValue || levelValue == offValue) {
            return false;
        }
        Filter filter = getFilter();
        if (filter == null) {
            return true;
        }
        return filter.isLoggable(record);
}

Check if this Handler would actually log a given LogRecord.

This method checks if the LogRecord has an appropriate Level and whether it satisfies any Filter. It also may make other Handler specific checks that might prevent a handler from logging the LogRecord. It will return false if the LogRecord is Null.

 abstract public  void publish(LogRecord record)
Publish a LogRecord.

The logging request was made initially to a Logger object,
which initialized the LogRecord and forwarded it here.

The Handler is responsible for formatting the message, when and
if necessary. The formatting should include localization.

 protected  void reportError(String msg,
    Exception ex,
    int code) 
{
        try {
            errorManager.error(msg, ex, code);
        } catch (Exception ex2) {
            System.err.println("Handler.reportError caught:");
            ex2.printStackTrace();
        }
}

Protected convenience method to report an error to this Handler's ErrorManager. Note that this method retrieves and uses the ErrorManager without doing a security check. It can therefore be used in environments where the caller may be non-privileged.

 public  void setEncoding(String encoding) throws SecurityException, UnsupportedEncodingException 
{
        checkAccess();
        if (encoding != null) {
            try {
                if(!java.nio.charset.Charset.isSupported(encoding)) {
                    throw new UnsupportedEncodingException(encoding);
                }
            } catch (java.nio.charset.IllegalCharsetNameException e) {
                throw new UnsupportedEncodingException(encoding);
            }
        }
        this.encoding = encoding;
}

Set the character encoding used by this Handler.

The encoding should be set before any LogRecords are written to the Handler.

 public  void setErrorManager(ErrorManager em) 
{
        checkAccess();
        if (em == null) {
           throw new NullPointerException();
        }
        errorManager = em;
}

Define an ErrorManager for this Handler.

The ErrorManager's "error" method will be invoked if any errors occur while using this Handler.

 public  void setFilter(Filter newFilter) throws SecurityException 
{
        checkAccess();
        filter = newFilter;
}

Set a Filter to control output on this Handler.

For each call of publish the Handler will call this Filter (if it is non-null) to check if the LogRecord should be published or discarded.

 public  void setFormatter(Formatter newFormatter) throws SecurityException 
{
        checkAccess();
        // Check for a null pointer:
        newFormatter.getClass();
        formatter = newFormatter;
}

Set a Formatter. This Formatter will be used to format LogRecords for this Handler.

Some Handlers may not use Formatters, in which case the Formatter will be remembered, but not used.

 public synchronized  void setLevel(Level newLevel) throws SecurityException 
{
        if (newLevel == null) {
            throw new NullPointerException();
        }
        checkAccess();
        logLevel = newLevel;
}

Set the log level specifying which message levels will be logged by this Handler. Message levels lower than this value will be discarded.

The intention is to allow developers to turn on voluminous logging, but to limit the messages that are sent to certain Handlers.