package nmp.util;
   
   import java.util.*;
   import java.io.*;
   
   /***
    * Class for logging.
    * There is a defaultLog, but application may have their own instance of the log.
    * It is supposed to be used in all projects. It is expected to evolve over time.
   */
  public class Log
  {
  	static Log defaultLog;
  
  	static {
  		defaultLog = new Log();
  	}
  	
  	Vector v;
  	
  	public Log() {
  		v = new Vector();
  		v.addElement( new PrintWriter( System.err));
  	}
  	
  	public void cleanSinkP() {
  		v.removeAllElements();
  	}
  	
  	public PrintWriter getWriterP() {
  		return new PrintWriter( new Writer() {
  			public void close() {
  				for( int i = 0; i < v.size(); i++) {
  					PrintWriter pw = (PrintWriter)v.elementAt( i);
  					pw.close();
  				}
  			}
  			public void flush() {
  				for( int i = 0; i < v.size(); i++) {
  					PrintWriter pw = (PrintWriter)v.elementAt( i);
  					pw.flush();
  				}
  			}
  			public void write(char[] cbuf, int off, int len) {
  				for( int i = 0; i < v.size(); i++) {
  					PrintWriter pw = (PrintWriter)v.elementAt( i);
  					pw.write( cbuf, off, len );
  					pw.flush();
  				}
  			}
  		});
  	}
  	
  	public void addSinkP( PrintWriter writer) {
  		v.addElement( writer);
  	}
  
  	public void addSinkP( String filename, boolean append) throws IOException {
  		addSinkP( new PrintWriter( new FileWriter( filename, append)));
  	}
  
  	public void addSinkP( String filename) throws IOException {
  		addSinkP( filename, false);
  	}
  
  	/***
  	 * Dums the error message. To be used only internally.
  	 */
  	private void messageP( String msg) {
  		for( int i = 0; i < v.size(); i++) {
  			PrintWriter pw = (PrintWriter)v.elementAt( i);
  			pw.println( msg);
  			pw.flush();
  		}
  	}
  
  	private void messageP( Throwable th) {
  		for( int i = 0; i < v.size(); i++) {
  			PrintWriter pw = (PrintWriter)v.elementAt( i);
  			th.printStackTrace( pw);
  			pw.flush();
  		}
  	}
  
  	/***
  	 * Dumps a log message.
  	 */
  	public void logP( String msg) {
  		messageP( msg);
  	}
  	/***
  	 * Dumps a log message.
  	 */
  	public void logTraceP( String msg) {
  		messageP( msg);
  		messageP( new Throwable());
  	}
  
  
 	/***
 	 * Dumps an wanring message.
 	 */
 	public void warningP( String msg) {
 		messageP( "WARN:" + msg);
 	}
 
 	/***
 	 * Dumps an error message. Throws the given exception (if given).
 	 */
 	public void errorP( String msg) {
 		messageP( "ERROR:" + msg);
 	}
 
 	public void errorP( Throwable th) {
 		messageP( "ERROR:" + th.getMessage());
 	}
 
 	public void errorP( String msg, Throwable th) {
 		errorP( msg);
 		errorP( th);
 	}
 
 	public void errorDumpP( Throwable th) {
 		errorP( th);
 		messageP( th);
 	}
 
 	public void errorDumpP( String msg, Throwable th) {
 		errorP( msg);
 		messageP( th);
 	}
 
 	public void errorThP( Throwable th) throws Throwable {
 		messageP( "ERROR:" + th.getMessage());
 		throw th;
 	}
 
 	/***
 	 * Dumps an internal error message. Throws the given exception (if given).
 	 */
 	public void internalErrorP( String msg) {
 		messageP( "INTERNAL ERROR:" + msg);
 	}
 
 	public void internalErrorP( Throwable th) {
 		messageP( "INTERNAL ERROR:" + th.getMessage());
 	}
 
 	public void internalErrorDumpP( Throwable th) {
 		internalErrorP( th);
 		messageP( th);
 	}
 
 	public void internalErrorThP( Throwable th) throws Throwable {
 		messageP( "INTERNAL ERROR:" + th.getMessage());
 		throw th;
 	}
 
 	/***
 	 * Dumps a  fatal error message. Exits virtual machine.
 	 */
 	public void fatalErrorP( String msg) {
 		messageP( "FATAL ERROR:" + msg);
 		System.exit( 0);
 	}
 
 	public void fatalErrorP( Throwable th) {
 		messageP( th);
 		System.exit( 0);
 	}
 
 	public static void cleanSink() {
 		defaultLog.cleanSinkP();
 	}
 	
 	public static PrintWriter getWriter() {
 		return defaultLog.getWriterP();
 	}
 	
 	public static void addSink( PrintWriter writer) {
 		defaultLog.addSinkP( writer);
 	}
 
 	public static void addSink( String filename, boolean append) throws IOException {
 		defaultLog.addSinkP( filename, append);
 	}
 
 	public static void addSink( String filename) throws IOException {
 		defaultLog.addSinkP( filename);
 	}
 
 	/***
 	 * Dumps a log message.
 	 */
 	public static void log( String msg) {
 		defaultLog.logP( msg);
 	}
 	public static void logTrace( String msg) {
 		defaultLog.logTraceP( msg);
 	}
 
 
 	/***
 	 * Dumps an wanring message.
 	 */
 	public static void warning( String msg) {
 		defaultLog.warningP( msg);
 	}
 
 	/***
 	 * Dumps an error message. Throws the given exception (if given).
 	 */
 	public static void error( String msg) {
 		defaultLog.errorP( msg);
 	}
 
 	public static void error( String msg, Throwable th) {
 		defaultLog.errorP( msg, th);
 	}
 
 	public static void error( Throwable th) {
 		defaultLog.errorP( th);
 	}
 
 	public static void errorDump( String msg, Throwable th) {
 		defaultLog.errorDumpP( msg, th);
 	}
 
 	public static void errorDump( Throwable th) {
 		defaultLog.errorDumpP( th);
 	}
 
 	public static void errorTh( Throwable th) throws Throwable {
 		defaultLog.errorThP( th);
 	}
 
 	/***
 	 * Dumps an internal error message. Throws the given exception (if given).
 	 */
 	public static void internalError( String msg) {
 		defaultLog.internalErrorP( msg);
 	}
 
 	public static void internalError( Throwable th) {
 		defaultLog.internalErrorP( th);
 	}
 
 	public static void internalErrorDump( Throwable th) {
 		defaultLog.internalErrorDumpP( th);
 	}
 
 	public static void internalErrorTh( Throwable th) throws Throwable {
 		defaultLog.internalErrorThP( th);
 	}
 
 	/***
 	 * Dumps a  fatal error message. Exits virtual machine.
 	 */
 	public static void fatalError( String msg) {
 		defaultLog.fatalErrorP( msg);
 	}
 
 	public static void fatalError( Throwable th) {
 		defaultLog.fatalErrorP( th);
 	}
 }