| /* gnu.classpath.tools.IOToolkit |
| Copyright (C) 2004 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
| 02111-1307 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| package gnu.classpath.tools; |
| |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.Reader; |
| import java.io.StringWriter; |
| import java.io.Writer; |
| |
| import java.util.Set; |
| |
| /** |
| * Provides various I/O-related helper methods. |
| * |
| * @author Julian Scheid |
| */ |
| public class IOToolkit |
| { |
| /** |
| * Prevents instantiation. |
| */ |
| private IOToolkit() {} |
| |
| /** |
| * Read all binary data from the given InputStream and write it to |
| * the given OutputStream. This method doesn't close either |
| * stream. |
| * |
| * @param in the stream from which to read data |
| * @param out the stream to which to write data |
| */ |
| public static void copyStream(InputStream in, OutputStream out) |
| throws IOException |
| { |
| byte[] buf = new byte[256]; |
| int nread; |
| |
| while ((nread = in.read(buf)) >= 0) { |
| out.write(buf, 0, nread); |
| } |
| } |
| |
| /** |
| * Read all character data from the given Reader and write it to |
| * the given Writer. This method doesn't close either stream. |
| * |
| * @param in the Reader from which to read character data |
| * @param out the Writer to which to write character data |
| */ |
| public static void copyStream(Reader in, Writer out) |
| throws IOException |
| { |
| char[] buf = new char[256]; |
| int nread; |
| |
| while ((nread = in.read(buf)) >= 0) { |
| out.write(buf, 0, nread); |
| } |
| } |
| |
| /** |
| * Recursively copy the contents of the input directory to the |
| * output directory. The output directory is created if it doesn't |
| * exist. If the output directory doesn't exist and can't be |
| * created, an IOException is thrown. |
| * |
| * @param sourceDir source directory from which to copy files |
| * @param targetDir target directory to which to copy files |
| * @param recursive if true, recursively copy subdirectoryies |
| * @param excludeDirs if non null, must be a Set of String. Each |
| * element from the set specifies the name of a direct |
| * subdirectory of the source directory which should be excluded |
| * from recursive copying. |
| */ |
| public static void copyDirectory(File sourceDir, File targetDir, |
| boolean recursive, |
| Set excludeDirs) |
| throws IOException |
| { |
| if (!targetDir.exists() && !targetDir.mkdirs()) { |
| throw new IOException("Cannot create directory " + targetDir); |
| } |
| |
| File[] sourceFiles = sourceDir.listFiles(); |
| for (int i=0; i<sourceFiles.length; ++i) { |
| if (sourceFiles[i].isDirectory()) { |
| if (recursive && (null == excludeDirs |
| || !excludeDirs.contains(sourceFiles[i].getName()))) { |
| File targetSubDir = new File(targetDir, |
| sourceFiles[i].getName()); |
| if (targetSubDir.exists() || targetSubDir.mkdir()) { |
| copyDirectory(sourceFiles[i], targetSubDir, recursive, null); |
| } |
| else { |
| throw new IOException("Cannot create directory " + targetSubDir); |
| } |
| } |
| } |
| else { |
| copyFile(sourceFiles[i], new File(targetDir, sourceFiles[i].getName())); |
| } |
| } |
| } |
| |
| /** |
| * Copy the contents of the input file to the output file. The |
| * output file's parent directory must exist. |
| * |
| * @param sourceFile specifies the file to copy |
| * @param targetFile specifies the file to create |
| */ |
| public static void copyFile(File sourceFile, File targetFile) |
| throws IOException |
| { |
| InputStream in = new FileInputStream(sourceFile); |
| OutputStream out = new FileOutputStream(targetFile); |
| int nread; |
| byte[] buf = new byte[512]; |
| while ((nread = in.read(buf)) >= 0) { |
| out.write(buf, 0, nread); |
| } |
| in.close(); |
| out.close(); |
| } |
| |
| /** |
| * Read the (remaining) contents of the given reader into a char |
| * array. This method doesn't close the reader when it is done. |
| * |
| * @param reader the Reader to read characters from |
| * @return an array with the contents of the Reader |
| */ |
| public static char[] readFully(Reader reader) |
| throws IOException |
| { |
| StringWriter writer = new StringWriter(); |
| final int readBufferSize = 256; |
| char[] chunk = new char[readBufferSize]; |
| int nread; |
| while ((nread=reader.read(chunk))>=0) { |
| writer.write(chunk,0,nread); |
| } |
| StringBuffer buffer = writer.getBuffer(); |
| char[] result = new char[buffer.length()]; |
| buffer.getChars(0, buffer.length(), result, 0); |
| return result; |
| } |
| |
| public static String getLineFromFile(File file, int line) |
| throws IOException |
| { |
| FileReader reader = new FileReader(file); |
| BufferedReader bufferedReader = new BufferedReader(reader); |
| while (line > 1) { |
| bufferedReader.readLine(); |
| -- line; |
| } |
| String result = bufferedReader.readLine(); |
| reader.close(); |
| return result; |
| } |
| |
| public static String getColumnDisplayLine(int column) |
| { |
| StringBuffer result = new StringBuffer(); |
| while (column > 0) { |
| result.append(' '); |
| --column; |
| } |
| result.append('^'); |
| return result.toString(); |
| } |
| |
| } |