org.eclipse.emf.cdo.releng.promotion/src/promoter/util/IO.java - cdo/cdo.infrastructure - Git at Google

 /*
  * Copyright (c) 2004 - 2012 Eike Stepper (Berlin, Germany) and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Eike Stepper - initial API and implementation
  */
 package promoter.util;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.CharArrayReader;
 import java.io.CharArrayWriter;
 import java.io.Closeable;
 import java.io.EOFException;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.Reader;
 import java.io.Writer;
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.Collection;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;

 /**
  * @author Eike Stepper
  */
 public final class IO
 {
   private static final int TIMEOUT = 10000;

   public static final int EOF = -1;

   public static final int DEFAULT_BUFFER_SIZE = 8192;

   private IO()
   {
   }

   public static void executeProcess(String command, OutputHandler handler)
   {
     File file = null;

     try
     {
       file = File.createTempFile("promoter-", ".tmp");
       writeFile(file, handler);
       executeProcess(command, file.getAbsolutePath());
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
     finally
     {
       if (file != null)
       {
         file.delete();
       }
     }
   }

   public static void executeProcess(String... command)
   {
     try
     {
       ProcessBuilder processBuilder = new ProcessBuilder(command);
       processBuilder.redirectErrorStream(true);

       final Process process = processBuilder.start();
       final InputStream stream = process.getInputStream();

       new Thread()
       {
         @Override
         public void run()
         {
           copy(stream, System.out, 1);
         }
       }.start();

       process.waitFor();
     }
     catch (Exception ex)
     {
       throw new RuntimeException(ex);
     }
   }

   public static boolean isExcluded(String name)
   {
     if (".git".equalsIgnoreCase(name))
     {
       return true;
     }

     if (".svn".equalsIgnoreCase(name))
     {
       return true;
     }

     if ("cvs".equalsIgnoreCase(name))
     {
       return true;
     }

     if (".git".equalsIgnoreCase(name))
     {
       return true;
     }

     if (".hg".equalsIgnoreCase(name))
     {
       return true;
     }

     if (".bzr".equalsIgnoreCase(name))
     {
       return true;
     }

     if ("SCCS".equalsIgnoreCase(name))
     {
       return true;
     }

     return false;
   }

   public static FileInputStream openInputStream(String fileName)
   {
     return openInputStream(new File(fileName));
   }

   public static FileInputStream openInputStream(File file)
   {
     try
     {
       return new FileInputStream(file);
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
   }

   public static FileOutputStream openOutputStream(String fileName)
   {
     return openOutputStream(new File(fileName));
   }

   public static FileOutputStream openOutputStream(File file)
   {
     try
     {
       return new FileOutputStream(file);
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
   }

   public static FileReader openReader(String fileName)
   {
     return openReader(new File(fileName));
   }

   public static FileReader openReader(File file)
   {
     try
     {
       return new FileReader(file);
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
   }

   public static FileWriter openWriter(String fileName)
   {
     return openWriter(new File(fileName));
   }

   public static FileWriter openWriter(File file)
   {
     try
     {
       return new FileWriter(file);
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
   }

   public static void close(Closeable closeable)
   {
     try
     {
       if (closeable != null)
       {
         closeable.close();
       }
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
   }

   public static void mkdirs(File folder)
   {
     if (!folder.exists())
     {
       if (!folder.mkdirs())
       {
         throw new RuntimeException("Unable to create directory " + folder.getAbsolutePath()); //$NON-NLS-1$
       }
     }
   }

   public static int delete(File file)
   {
     if (file == null)
     {
       return 0;
     }

     int deleted = 0;
     if (file.isDirectory())
     {
       for (File child : file.listFiles())
       {
         deleted += delete(child);
       }
     }

     if (file.delete())
     {
       return deleted + 1;
     }

     file.deleteOnExit();
     return deleted;
   }

   public static void copyTree(File source, File target)
   {
     if (source.isDirectory())
     {
       mkdirs(target);
       File[] files = source.listFiles();
       for (File file : files)
       {
         String name = file.getName();
         copyTree(new File(source, name), new File(target, name));
       }
     }
     else
     {
       copyFile(source, target);
     }
   }

   public static void copyTrees(Collection<File> sources, File target)
   {
     for (File source : sources)
     {
       copyTree(source, target);
     }
   }

   public static long copyBinary(InputStream inputStream, OutputStream outputStream) throws IOException
   {
     if (!(inputStream instanceof BufferedInputStream) && !(inputStream instanceof ByteArrayInputStream))
     {
       inputStream = new BufferedInputStream(inputStream);
     }

     if (!(outputStream instanceof BufferedOutputStream) && !(outputStream instanceof ByteArrayOutputStream))
     {
       outputStream = new BufferedOutputStream(outputStream);
     }

     long size = 0;
     int b;
     while ((b = inputStream.read()) != EOF)
     {
       outputStream.write(b);
       ++size;
     }

     outputStream.flush();
     return size;
   }

   public static void copyBinary(InputStream inputStream, OutputStream outputStream, long size) throws IOException
   {
     if (!(inputStream instanceof BufferedInputStream) && !(inputStream instanceof ByteArrayInputStream))
     {
       inputStream = new BufferedInputStream(inputStream);
     }

     if (!(outputStream instanceof BufferedOutputStream) && !(outputStream instanceof ByteArrayOutputStream))
     {
       outputStream = new BufferedOutputStream(outputStream);
     }

     while (size > 0L)
     {
       int b = inputStream.read();
       if (b == EOF)
       {
         throw new EOFException();
       }

       outputStream.write(b);
       --size;
     }

     outputStream.flush();
   }

   public static long copyCharacter(Reader reader, Writer writer) throws IOException
   {
     if (!(reader instanceof BufferedReader) && !(reader instanceof CharArrayReader))
     {
       reader = new BufferedReader(reader);
     }

     if (!(writer instanceof BufferedWriter) && !(writer instanceof CharArrayWriter))
     {
       writer = new BufferedWriter(writer);
     }

     long size = 0;
     int c;
     while ((c = reader.read()) != EOF)
     {
       writer.write(c);
       ++size;
     }

     writer.flush();
     return size;
   }

   public static void copyCharacter(Reader reader, Writer writer, long size) throws IOException
   {
     if (!(reader instanceof BufferedReader) && !(reader instanceof CharArrayReader))
     {
       reader = new BufferedReader(reader);
     }

     if (!(writer instanceof BufferedWriter) && !(writer instanceof CharArrayWriter))
     {
       writer = new BufferedWriter(writer);
     }

     while (size > 0L)
     {
       int c = reader.read();
       if (c == EOF)
       {
         throw new EOFException();
       }

       writer.write(c);
       --size;
     }

     writer.flush();
   }

   public static int copy(InputStream input, OutputStream output, int size, byte buffer[])
   {
     try
     {
       int written = 0;
       int bufferSize = buffer.length;
       int n = Math.min(size, bufferSize);
       while (n > 0 && (n = input.read(buffer, 0, n)) != -1)
       {
         output.write(buffer, 0, n);
         written += n;
         size -= n;
         n = Math.min(size, bufferSize);
       }

       return written;
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
   }

   public static void copy(InputStream input, OutputStream output, byte buffer[])
   {
     try
     {
       int n;
       while ((n = input.read(buffer)) != -1)
       {
         output.write(buffer, 0, n);
       }
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
   }

   public static void copy(InputStream input, OutputStream output, int bufferSize)
   {
     copy(input, output, new byte[bufferSize]);
   }

   public static void copy(InputStream input, OutputStream output)
   {
     copy(input, output, DEFAULT_BUFFER_SIZE);
   }

   public static void copyFile(File source, File target)
   {
     mkdirs(target.getParentFile());
     FileInputStream input = null;
     FileOutputStream output = null;

     try
     {
       input = openInputStream(source);
       output = openOutputStream(target);
       copy(input, output);
     }
     finally
     {
       try
       {
         close(input);
       }
       finally
       {
         close(output);
       }
     }
   }

   public static String readTextFile(File file)
   {
     Reader input = openReader(file);

     try
     {
       CharArrayWriter output = new CharArrayWriter();
       copyCharacter(input, output);
       return output.toString();
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
     finally
     {
       close(input);
     }
   }

   public static byte[] readFile(File file)
   {
     if (file.length() > Integer.MAX_VALUE)
     {
       throw new IllegalArgumentException("File too long: " + file.length()); //$NON-NLS-1$
     }

     int size = (int)file.length();
     FileInputStream input = openInputStream(file);

     try
     {
       ByteArrayOutputStream output = new ByteArrayOutputStream(size);
       copy(input, output);
       return output.toByteArray();
     }
     finally
     {
       close(input);
     }
   }

   public static void readFile(File file, InputHandler handler)
   {
     FileInputStream input = openInputStream(file);

     try
     {
       handler.handleInput(input);
     }
     catch (Exception ex)
     {
       throw new RuntimeException(ex);
     }
     finally
     {
       close(input);
     }
   }

   public static void readURL(String url, InputHandler handler)
   {
     InputStream input = null;

     try
     {
       URLConnection connection = new URL(url).openConnection();
       connection.setConnectTimeout(TIMEOUT);

       input = connection.getInputStream();
       handler.handleInput(input);
     }
     catch (Exception ex)
     {
       throw new RuntimeException(ex);
     }
     finally
     {
       close(input);
     }
   }

   public static void writeFile(File file, byte[] bytes)
   {
     FileOutputStream output = openOutputStream(file);

     try
     {
       ByteArrayInputStream input = new ByteArrayInputStream(bytes);
       copy(input, output);
     }
     finally
     {
       close(output);
     }
   }

   public static void writeFile(File file, OutputHandler handler)
   {
     FileOutputStream output = openOutputStream(file);

     try
     {
       handler.handleOutput(output);
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
     finally
     {
       close(output);
     }
   }

   public static void emptyFile(File file)
   {
     writeFile(file, new byte[0]);
   }

   public static boolean equals(InputStream stream1, InputStream stream2)
   {
     try
     {
       for (;;)
       {
         int byte1 = stream1.read();
         int byte2 = stream2.read();

         if (byte1 != byte2)
         {
           return false;
         }

         if (byte1 == -1)// Implies byte2 == -1
         {
           return true;
         }
       }
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
   }

   public static void unzip(File zipFile, File targetFolder, String prefix)
   {
     FileInputStream fis = openInputStream(zipFile);

     try
     {
       unzip(fis, targetFolder, prefix);
     }
     finally
     {
       close(fis);
     }
   }

   public static void unzip(URL url, File targetFolder, String prefix)
   {
     InputStream in = null;

     try
     {
       in = url.openStream();
       unzip(in, targetFolder, prefix);
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
     finally
     {
       IO.close(in);
     }
   }

   public static void unzip(InputStream inputStream, File targetFolder, String prefix)
   {
     final byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
     ZipInputStream zis = null;

     try
     {
       zis = new ZipInputStream(new BufferedInputStream(inputStream, DEFAULT_BUFFER_SIZE));

       ZipEntry entry;
       while ((entry = zis.getNextEntry()) != null)
       {
         String name = entry.getName();
         if (prefix != null)
         {
           if (name.startsWith(prefix))
           {
             name = name.substring(prefix.length());
             if (name.length() == 0)
             {
               continue;
             }
           }
           else
           {
             continue;
           }
         }

         File target = new File(targetFolder, name);

         if (entry.isDirectory())
         {
           target.mkdirs();
         }
         else
         {
           target.getParentFile().mkdirs();
           FileOutputStream out = openOutputStream(target);

           try
           {
             copy(zis, out, buffer);
           }
           finally
           {
             close(out);
           }
         }
       }
     }
     catch (IOException ex)
     {
       throw new RuntimeException(ex);
     }
     finally
     {
       close(zis);
     }
   }

   /**
    * @author Eike Stepper
    */
   public interface InputHandler
   {
     public void handleInput(InputStream in) throws IOException;
   }

   /**
    * @author Eike Stepper
    */
   public interface OutputHandler
   {
     public static final OutputHandler EMPTY = new OutputHandler()
     {
       public void handleOutput(OutputStream out) throws IOException
       {
         // Do nothing
       }
     };

     public void handleOutput(OutputStream out) throws IOException;
   }
 }
	/*
	* Copyright (c) 2004 - 2012 Eike Stepper (Berlin, Germany) and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Eike Stepper - initial API and implementation
	*/
	package promoter.util;

	import java.io.BufferedInputStream;
	import java.io.BufferedOutputStream;
	import java.io.BufferedReader;
	import java.io.BufferedWriter;
	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.CharArrayReader;
	import java.io.CharArrayWriter;
	import java.io.Closeable;
	import java.io.EOFException;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.FileReader;
	import java.io.FileWriter;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.Reader;
	import java.io.Writer;
	import java.net.URL;
	import java.net.URLConnection;
	import java.util.Collection;
	import java.util.zip.ZipEntry;
	import java.util.zip.ZipInputStream;

	/**
	* @author Eike Stepper
	*/
	public final class IO
	{
	private static final int TIMEOUT = 10000;

	public static final int EOF = -1;

	public static final int DEFAULT_BUFFER_SIZE = 8192;

	private IO()
	{
	}

	public static void executeProcess(String command, OutputHandler handler)
	{
	File file = null;

	try
	{
	file = File.createTempFile("promoter-", ".tmp");
	writeFile(file, handler);
	executeProcess(command, file.getAbsolutePath());
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	finally
	{
	if (file != null)
	{
	file.delete();
	}
	}
	}

	public static void executeProcess(String... command)
	{
	try
	{
	ProcessBuilder processBuilder = new ProcessBuilder(command);
	processBuilder.redirectErrorStream(true);

	final Process process = processBuilder.start();
	final InputStream stream = process.getInputStream();

	new Thread()
	{
	@Override
	public void run()
	{
	copy(stream, System.out, 1);
	}
	}.start();

	process.waitFor();
	}
	catch (Exception ex)
	{
	throw new RuntimeException(ex);
	}
	}

	public static boolean isExcluded(String name)
	{
	if (".git".equalsIgnoreCase(name))
	{
	return true;
	}

	if (".svn".equalsIgnoreCase(name))
	{
	return true;
	}

	if ("cvs".equalsIgnoreCase(name))
	{
	return true;
	}

	if (".git".equalsIgnoreCase(name))
	{
	return true;
	}

	if (".hg".equalsIgnoreCase(name))
	{
	return true;
	}

	if (".bzr".equalsIgnoreCase(name))
	{
	return true;
	}

	if ("SCCS".equalsIgnoreCase(name))
	{
	return true;
	}

	return false;
	}

	public static FileInputStream openInputStream(String fileName)
	{
	return openInputStream(new File(fileName));
	}

	public static FileInputStream openInputStream(File file)
	{
	try
	{
	return new FileInputStream(file);
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	}

	public static FileOutputStream openOutputStream(String fileName)
	{
	return openOutputStream(new File(fileName));
	}

	public static FileOutputStream openOutputStream(File file)
	{
	try
	{
	return new FileOutputStream(file);
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	}

	public static FileReader openReader(String fileName)
	{
	return openReader(new File(fileName));
	}

	public static FileReader openReader(File file)
	{
	try
	{
	return new FileReader(file);
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	}

	public static FileWriter openWriter(String fileName)
	{
	return openWriter(new File(fileName));
	}

	public static FileWriter openWriter(File file)
	{
	try
	{
	return new FileWriter(file);
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	}

	public static void close(Closeable closeable)
	{
	try
	{
	if (closeable != null)
	{
	closeable.close();
	}
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	}

	public static void mkdirs(File folder)
	{
	if (!folder.exists())
	{
	if (!folder.mkdirs())
	{
	throw new RuntimeException("Unable to create directory " + folder.getAbsolutePath()); //$NON-NLS-1$
	}
	}
	}

	public static int delete(File file)
	{
	if (file == null)
	{
	return 0;
	}

	int deleted = 0;
	if (file.isDirectory())
	{
	for (File child : file.listFiles())
	{
	deleted += delete(child);
	}
	}

	if (file.delete())
	{
	return deleted + 1;
	}

	file.deleteOnExit();
	return deleted;
	}

	public static void copyTree(File source, File target)
	{
	if (source.isDirectory())
	{
	mkdirs(target);
	File[] files = source.listFiles();
	for (File file : files)
	{
	String name = file.getName();
	copyTree(new File(source, name), new File(target, name));
	}
	}
	else
	{
	copyFile(source, target);
	}
	}

	public static void copyTrees(Collection<File> sources, File target)
	{
	for (File source : sources)
	{
	copyTree(source, target);
	}
	}

	public static long copyBinary(InputStream inputStream, OutputStream outputStream) throws IOException
	{
	if (!(inputStream instanceof BufferedInputStream) && !(inputStream instanceof ByteArrayInputStream))
	{
	inputStream = new BufferedInputStream(inputStream);
	}

	if (!(outputStream instanceof BufferedOutputStream) && !(outputStream instanceof ByteArrayOutputStream))
	{
	outputStream = new BufferedOutputStream(outputStream);
	}

	long size = 0;
	int b;
	while ((b = inputStream.read()) != EOF)
	{
	outputStream.write(b);
	++size;
	}

	outputStream.flush();
	return size;
	}

	public static void copyBinary(InputStream inputStream, OutputStream outputStream, long size) throws IOException
	{
	if (!(inputStream instanceof BufferedInputStream) && !(inputStream instanceof ByteArrayInputStream))
	{
	inputStream = new BufferedInputStream(inputStream);
	}

	if (!(outputStream instanceof BufferedOutputStream) && !(outputStream instanceof ByteArrayOutputStream))
	{
	outputStream = new BufferedOutputStream(outputStream);
	}

	while (size > 0L)
	{
	int b = inputStream.read();
	if (b == EOF)
	{
	throw new EOFException();
	}

	outputStream.write(b);
	--size;
	}

	outputStream.flush();
	}

	public static long copyCharacter(Reader reader, Writer writer) throws IOException
	{
	if (!(reader instanceof BufferedReader) && !(reader instanceof CharArrayReader))
	{
	reader = new BufferedReader(reader);
	}

	if (!(writer instanceof BufferedWriter) && !(writer instanceof CharArrayWriter))
	{
	writer = new BufferedWriter(writer);
	}

	long size = 0;
	int c;
	while ((c = reader.read()) != EOF)
	{
	writer.write(c);
	++size;
	}

	writer.flush();
	return size;
	}

	public static void copyCharacter(Reader reader, Writer writer, long size) throws IOException
	{
	if (!(reader instanceof BufferedReader) && !(reader instanceof CharArrayReader))
	{
	reader = new BufferedReader(reader);
	}

	if (!(writer instanceof BufferedWriter) && !(writer instanceof CharArrayWriter))
	{
	writer = new BufferedWriter(writer);
	}

	while (size > 0L)
	{
	int c = reader.read();
	if (c == EOF)
	{
	throw new EOFException();
	}

	writer.write(c);
	--size;
	}

	writer.flush();
	}

	public static int copy(InputStream input, OutputStream output, int size, byte buffer[])
	{
	try
	{
	int written = 0;
	int bufferSize = buffer.length;
	int n = Math.min(size, bufferSize);
	while (n > 0 && (n = input.read(buffer, 0, n)) != -1)
	{
	output.write(buffer, 0, n);
	written += n;
	size -= n;
	n = Math.min(size, bufferSize);
	}

	return written;
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	}

	public static void copy(InputStream input, OutputStream output, byte buffer[])
	{
	try
	{
	int n;
	while ((n = input.read(buffer)) != -1)
	{
	output.write(buffer, 0, n);
	}
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	}

	public static void copy(InputStream input, OutputStream output, int bufferSize)
	{
	copy(input, output, new byte[bufferSize]);
	}

	public static void copy(InputStream input, OutputStream output)
	{
	copy(input, output, DEFAULT_BUFFER_SIZE);
	}

	public static void copyFile(File source, File target)
	{
	mkdirs(target.getParentFile());
	FileInputStream input = null;
	FileOutputStream output = null;

	try
	{
	input = openInputStream(source);
	output = openOutputStream(target);
	copy(input, output);
	}
	finally
	{
	try
	{
	close(input);
	}
	finally
	{
	close(output);
	}
	}
	}

	public static String readTextFile(File file)
	{
	Reader input = openReader(file);

	try
	{
	CharArrayWriter output = new CharArrayWriter();
	copyCharacter(input, output);
	return output.toString();
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	finally
	{
	close(input);
	}
	}

	public static byte[] readFile(File file)
	{
	if (file.length() > Integer.MAX_VALUE)
	{
	throw new IllegalArgumentException("File too long: " + file.length()); //$NON-NLS-1$
	}

	int size = (int)file.length();
	FileInputStream input = openInputStream(file);

	try
	{
	ByteArrayOutputStream output = new ByteArrayOutputStream(size);
	copy(input, output);
	return output.toByteArray();
	}
	finally
	{
	close(input);
	}
	}

	public static void readFile(File file, InputHandler handler)
	{
	FileInputStream input = openInputStream(file);

	try
	{
	handler.handleInput(input);
	}
	catch (Exception ex)
	{
	throw new RuntimeException(ex);
	}
	finally
	{
	close(input);
	}
	}

	public static void readURL(String url, InputHandler handler)
	{
	InputStream input = null;

	try
	{
	URLConnection connection = new URL(url).openConnection();
	connection.setConnectTimeout(TIMEOUT);

	input = connection.getInputStream();
	handler.handleInput(input);
	}
	catch (Exception ex)
	{
	throw new RuntimeException(ex);
	}
	finally
	{
	close(input);
	}
	}

	public static void writeFile(File file, byte[] bytes)
	{
	FileOutputStream output = openOutputStream(file);

	try
	{
	ByteArrayInputStream input = new ByteArrayInputStream(bytes);
	copy(input, output);
	}
	finally
	{
	close(output);
	}
	}

	public static void writeFile(File file, OutputHandler handler)
	{
	FileOutputStream output = openOutputStream(file);

	try
	{
	handler.handleOutput(output);
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	finally
	{
	close(output);
	}
	}

	public static void emptyFile(File file)
	{
	writeFile(file, new byte[0]);
	}

	public static boolean equals(InputStream stream1, InputStream stream2)
	{
	try
	{
	for (;;)
	{
	int byte1 = stream1.read();
	int byte2 = stream2.read();

	if (byte1 != byte2)
	{
	return false;
	}

	if (byte1 == -1)// Implies byte2 == -1
	{
	return true;
	}
	}
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	}

	public static void unzip(File zipFile, File targetFolder, String prefix)
	{
	FileInputStream fis = openInputStream(zipFile);

	try
	{
	unzip(fis, targetFolder, prefix);
	}
	finally
	{
	close(fis);
	}
	}

	public static void unzip(URL url, File targetFolder, String prefix)
	{
	InputStream in = null;

	try
	{
	in = url.openStream();
	unzip(in, targetFolder, prefix);
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	finally
	{
	IO.close(in);
	}
	}

	public static void unzip(InputStream inputStream, File targetFolder, String prefix)
	{
	final byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
	ZipInputStream zis = null;

	try
	{
	zis = new ZipInputStream(new BufferedInputStream(inputStream, DEFAULT_BUFFER_SIZE));

	ZipEntry entry;
	while ((entry = zis.getNextEntry()) != null)
	{
	String name = entry.getName();
	if (prefix != null)
	{
	if (name.startsWith(prefix))
	{
	name = name.substring(prefix.length());
	if (name.length() == 0)
	{
	continue;
	}
	}
	else
	{
	continue;
	}
	}

	File target = new File(targetFolder, name);

	if (entry.isDirectory())
	{
	target.mkdirs();
	}
	else
	{
	target.getParentFile().mkdirs();
	FileOutputStream out = openOutputStream(target);

	try
	{
	copy(zis, out, buffer);
	}
	finally
	{
	close(out);
	}
	}
	}
	}
	catch (IOException ex)
	{
	throw new RuntimeException(ex);
	}
	finally
	{
	close(zis);
	}
	}

	/**
	* @author Eike Stepper
	*/
	public interface InputHandler
	{
	public void handleInput(InputStream in) throws IOException;
	}

	/**
	* @author Eike Stepper
	*/
	public interface OutputHandler
	{
	public static final OutputHandler EMPTY = new OutputHandler()
	{
	public void handleOutput(OutputStream out) throws IOException
	{
	// Do nothing
	}
	};

	public void handleOutput(OutputStream out) throws IOException;
	}
	}