protected Log() 
{
        this.logContexts = new HashMap();
        this.logTargets = new LogTarget[0];
        this.debuglevel = 100;
}

Creates a new Log instance. The Log is used to manage the log targets.

 public synchronized  void addTarget(LogTarget target) 
{
        if (target == null) {
            throw new NullPointerException();
        }
        final LogTarget[] data = new LogTarget[this.logTargets.length + 1];
        System.arraycopy(this.logTargets, 0, data, 0, this.logTargets.length);
        data[this.logTargets.length] = target;
        this.logTargets = data;
}

Adds a log target to this facility. Log targets get informed, via the LogTarget interface, whenever a message is logged with this class.

 public static LogContext createContext(Class context) 
{
        return createContext(context.getName());
}

Creates a log context.

 public static LogContext createContext(String context) 
{
        return getInstance().internalCreateContext(context);
}

Creates a log context.

 public static  void debug(Object message) 
{
        log(LogTarget.DEBUG, message);
}

A convenience method for logging a 'debug' message.

 public static  void debug(Object message,
    Exception e) 
{
        log(LogTarget.DEBUG, message, e);
}

A convenience method for logging a 'debug' message.

 protected static synchronized  void defineLog(Log log) 
{
        singleton = log;
}

Redefines or clears the currently used log instance.

 protected  void doLog(int level,
    Object message) 
{
        if (level  > 3) {
            level = 3;
        }
        if (level < = this.debuglevel) {
            for (int i = 0; i <  this.logTargets.length; i++) {
                final LogTarget t = this.logTargets[i];
                t.log(level, message);
            }
        }
}

Logs a message to the main log stream. All attached log targets will also receive this message. If the given log-level is higher than the given debug-level in the main config file, no logging will be done.

 protected  void doLog(int level,
    Object message,
    Exception e) 
{
        if (level  > 3) {
            level = 3;
        }
        if (level < = this.debuglevel) {
            for (int i = 0; i <  this.logTargets.length; i++) {
                final LogTarget t = this.logTargets[i];
                t.log(level, message, e);
            }
        }
}

Logs a message to the main log stream. All attached logTargets will also receive this message. If the given log-level is higher than the given debug-level in the main config file, no logging will be done.

The exception's stacktrace will be appended to the log-stream

 public static  void error(Object message) 
{
        log(LogTarget.ERROR, message);
}

A convenience method for logging an 'error' message.

 public static  void error(Object message,
    Exception e) 
{
        log(LogTarget.ERROR, message, e);
}

A convenience method for logging an 'error' message.

 public int getDebuglevel() 
{
        return this.debuglevel;
}

Returns the currently defined debug level. The higher the level, the more details are printed.

 public static synchronized Log getInstance() 
{
        if (singleton == null) {
            singleton = new Log();
        }
        return singleton;
}

Returns the singleton Log instance. A new instance is created if necessary.

 public LogTarget[] getTargets() 
{
        return (LogTarget[]) this.logTargets.clone();
}

Returns the registered logtargets.

 public static  void info(Object message) 
{
        log(LogTarget.INFO, message);
}

A convenience method for logging an 'info' message.

 public static  void info(Object message,
    Exception e) 
{
        log(LogTarget.INFO, message, e);
}

A convenience method for logging an 'info' message.

 public  void init() 
{
        // this method is intentionally empty.
}

Initializes the logging system. Implementors should override this method to supply their own log configuration.

 protected LogContext internalCreateContext(String context) 
{
        synchronized (this) {
            LogContext ctx = (LogContext) this.logContexts.get(context);
            if (ctx == null) {
                ctx = new LogContext(context);
                this.logContexts.put(context, ctx);
            }
            return ctx;
        }
}

Creates a log context.

 public static boolean isDebugEnabled() 
{
        return getInstance().getDebuglevel()  >= LogTarget.DEBUG;
}

Returns true, if the log level allows debug messages to be printed.

 public static boolean isErrorEnabled() 
{
        return getInstance().getDebuglevel()  >= LogTarget.ERROR;
}

Returns true, if the log level allows error messages to be printed.

 public static boolean isInfoEnabled() 
{
        return getInstance().getDebuglevel()  >= LogTarget.INFO;
}

Returns true, if the log level allows informational messages to be printed.

 public static boolean isWarningEnabled() 
{
        return getInstance().getDebuglevel()  >= LogTarget.WARN;
}

Returns true, if the log level allows warning messages to be printed.

 public static  void log(int level,
    Object message) 
{
        getInstance().doLog(level, message);
}

Logs a message to the main log stream. All attached log targets will also receive this message. If the given log-level is higher than the given debug-level in the main config file, no logging will be done.

 public static  void log(int level,
    Object message,
    Exception e) 
{
        getInstance().doLog(level, message, e);
}

Logs a message to the main log stream. All attached logTargets will also receive this message. If the given log-level is higher than the given debug-level in the main config file, no logging will be done.

The exception's stacktrace will be appended to the log-stream

 public synchronized  void removeTarget(LogTarget target) 
{
        if (target == null) {
            throw new NullPointerException();
        }
        final ArrayList l = new ArrayList();
        l.addAll(Arrays.asList(this.logTargets));
        l.remove(target);
        final LogTarget[] targets = new LogTarget[l.size()];
        this.logTargets = (LogTarget[]) l.toArray(targets);
}

Removes a log target from this facility.

 public synchronized  void replaceTargets(LogTarget target) 
{
        if (target == null) {
            throw new NullPointerException();
        }
        this.logTargets = new LogTarget[]{target};
}

Replaces all log targets by the given target.

 protected  void setDebuglevel(int debuglevel) 
{
        this.debuglevel = debuglevel;
}

Defines the debug level for the log system.

 public static  void warn(Object message) 
{
        log(LogTarget.WARN, message);
}

A convenience method for logging a 'warning' message.

 public static  void warn(Object message,
    Exception e) 
{
        log(LogTarget.WARN, message, e);
}

A convenience method for logging a 'warning' message.