package nmp.io;
   
   import java.io.*;
   
   /***
    * @version 0.045 12-Dec-2000
    * @author Nuno Pregui�a
    */
   public class Utilities
  {
  	public final static int BUFFER_SIZE = 1024;
  	public final static byte[] globbuf = new byte[BUFFER_SIZE];
  	/***
  	* Produces filename
  	*@param path Pathname
  	*@param filename Filename
  	*/
  	public static String produceFullPath( String path, String filename)
  	{
  		char ch = java.io.File.separatorChar;
  		if( path.charAt( path.length() - 1) == ch)
  		{
  			if( filename.length() == 0 || filename.charAt( 0) != ch)
  				return path + filename;
  			else
  				return path.substring( 0, path.length() - 2) + filename;
  		}
  		else
  		{
  			if( filename.length() == 0 || filename.charAt( 0) != ch)
  				return path + String.valueOf( ch) + filename;
  			else
  				return path + filename;
  		}
  	}
  
  	/***
  	 * Returns the serialized form of the given object
  	 */
  	public static byte []serialize( Object obj) throws IOException {
  		ByteArrayOutputStream bos = new ByteArrayOutputStream();
  		ObjectOutputStream oos = new ObjectOutputStream( bos);
  		oos.writeObject( obj);
  		oos.flush();
  		oos.close();
  		bos.flush();
  		bos.close();
  		return bos.toByteArray();
  	}
  	/***
  	 * Returns the given object
  	 */
  	public static Object unserialize( byte []arr) throws IOException {
  		try {
  			ByteArrayInputStream bis = new ByteArrayInputStream( arr);
  			ObjectInputStream ois = new ObjectInputStream( bis);
  			Object obj = ois.readObject();
  			ois.close();
  			bis.close();
  			return obj;
  		} catch( ClassNotFoundException e) {
  			throw new IOException( "Class not found exception in unserialize");
  		}
  	}
  	
  	/***
  	 * Cleanups outpurstream and associated file - used to delete partially downloaded
  	 * resources
  	 */
  	public static void cleanupCon( File f, OutputStream out) {
  		if( out != null)
  			try {
  				out.close();
  			} catch( Exception e0) {
  				// do nothing
  			}
  		if( f != null)
  			f.delete();
  	}
  	
  	/***
  	 * Dumps in to out
  	 */
  	public static void copy( InputStream in, OutputStream out) throws IOException {
  		byte []buffer = new byte[BUFFER_SIZE];
  		
  		while( true) {
  			int len = in.read( buffer, 0, BUFFER_SIZE);
  			if( len <= 0)
  				break;
  			out.write( buffer, 0, len);
          }
  	}
  
  	/***
  	 * Load the contents of the file f into buf (appending)
  	 * 
  	 * @return Returns true if the file has been successfully read
  	 */
 	public static boolean loadText( File f, StringBuffer buf) throws IOException {
 		if( buf == null)
 			return false;
 
 		BufferedReader reader = new BufferedReader( new FileReader( f));
 		char []buffer = new char[BUFFER_SIZE];
 		
 		while( true) {
 			int len = reader.read( buffer, 0, BUFFER_SIZE);
 			if( len <= 0)
 				break;
 			buf.append( buffer, 0, len);
         }
 		reader.close();
 		return true;
 	}
 
 	/***
 	 * Save the contents of buf in file f
 	 * 
 	 * @return Returns true if the file has been successfully saved
 	 */
 	public static boolean saveText( File f, String buf) throws IOException {
 		if( buf == null)
 			return false;
 		if( f == null)
 			return false;
 
 		BufferedWriter writer = new BufferedWriter( new FileWriter( f));
 		char []buffer = new char[BUFFER_SIZE];
 		
 		int len = buf.length();
 		int curpos = 0;
 		
 		while( curpos < len) {
 			int nextpos = curpos + BUFFER_SIZE;
 			if( nextpos > len)
 				nextpos = len;
 			buf.getChars( curpos, nextpos, buffer, 0);
 			writer.write( buffer, 0, nextpos - curpos);
 			curpos = nextpos;
         }
 		writer.flush();
 		writer.close();
 		return true;
 	}
 	
 	/***
 	 * Opens object output stream for appending
 	 */
 	public static ObjectOutputStream openAppend( File f) throws IOException, ClassNotFoundException {
 		if( ! f.exists())
 			return new ObjectOutputStream( new FileOutputStream( f));
 		File faux;
 		for( int i = 0; ; ) {
 			faux = new File( f.getAbsolutePath() + "." + i);
 			if( ! faux.exists())
 				break;
 		}
 		if( ! f.renameTo( faux))
 			throw new IOException( "Unable to rename");
 		ObjectInputStream ois = new ObjectInputStream( new BufferedInputStream( new FileInputStream( faux)));
 		ObjectOutputStream oos = new ObjectOutputStream( new BufferedOutputStream( new FileOutputStream( f)));
 		for( ; ; ) {
 			Object obj = ois.readObject();
 			if( obj == null)
 				break;
 			oos.writeObject( obj);
 		}
 		ois.close();
 		return oos;
 	}
 	
 	/***
 	 * Merges all file with name " prefix | int | suffix " into file filename
 	 * 
 	 * @param delete If true original files are deleted
 	 */
 	public static void merge( int start, String filename, String prefix, String sufix, boolean delete) throws IOException {
 		File f = new File( filename);
 		BufferedOutputStream bos = null;
 		if( f.exists())
 			bos = new BufferedOutputStream( new FileOutputStream( filename, true));
 		else
 			bos = new BufferedOutputStream( new FileOutputStream( filename));
 		for( int i = start; ; i++) {
 			File f2 = new File( prefix + i + sufix);
 			if( ! f2.exists())
 				break;
 			BufferedInputStream bis = new BufferedInputStream( new FileInputStream( f2));
 			copy( bis, bos);
 			bis.close();
 			if( delete)
 				f2.delete();
 		}
 		bos.flush();
 		bos.close();
 	}
 	
 	/***
 	 * Copies files from src to dst
 	 */
 	public static void copyFile( String src, String dst) throws IOException{
 		copyFile( new File(src), new File(dst));
 	}
 	public static void copyFile( File src, File dst) throws IOException{
 		InputStream is = new FileInputStream( src);
 		OutputStream os = new FileOutputStream( dst);
 		for( ; ; ) {
 			int count = is.read( globbuf);
 			if( count <= 0)
 				break;
 			os.write( globbuf, 0, count);
 		}
 		os.flush();
 		os.close();
 		is.close();
 	}
 	/***
 	 * clean dir
 	 */
 	public static void cleanDir( String dir) {
 		File f = new File( dir);
 		if( ! f.isDirectory())
 			return;
 		File[] fs = f.listFiles();
 		if( fs != null) {
 			for( int i = 0; i < fs.length; i++) {
 				fs[i].delete();
 			}
 		}
 	}
 }