package be.nikiroo.utils;
-import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
-import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
-import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
+import be.nikiroo.utils.streams.MarkableFileInputStream;
+
/**
- * This class offer some utilities based around Streams.
+ * This class offer some utilities based around Streams and Files.
*
* @author niki
*/
* @param target
* the target {@link File}
*
+ * @return the number of bytes written
+ *
* @throws IOException
* in case of I/O error
*/
- public static void write(InputStream in, File target) throws IOException {
+ public static long write(InputStream in, File target) throws IOException {
OutputStream out = new FileOutputStream(target);
try {
- write(in, out);
+ return write(in, out);
} finally {
out.close();
}
* @param out
* the target {@link OutputStream}
*
+ * @return the number of bytes written
+ *
* @throws IOException
* in case of I/O error
*/
- public static void write(InputStream in, OutputStream out)
+ public static long write(InputStream in, OutputStream out)
throws IOException {
- byte buffer[] = new byte[4069];
- for (int len = 0; (len = in.read(buffer)) > 0;) {
+ long written = 0;
+ byte buffer[] = new byte[4096];
+ int len = in.read(buffer);
+ while (len > -1) {
out.write(buffer, 0, len);
+ written += len;
+ len = in.read(buffer);
}
+
+ return written;
}
/**
}
}
+ /**
+ * Unzip the given ZIP file into the target directory.
+ *
+ * @param zipFile
+ * the ZIP file
+ * @param targetDirectory
+ * the target directory
+ *
+ * @return the number of extracted files (not directories)
+ *
+ * @throws IOException
+ * in case of I/O errors
+ */
+ public static long unzip(File zipFile, File targetDirectory)
+ throws IOException {
+ long count = 0;
+
+ if (targetDirectory.exists() && targetDirectory.isFile()) {
+ throw new IOException("Cannot unzip " + zipFile + " into "
+ + targetDirectory + ": it is not a directory");
+ }
+
+ targetDirectory.mkdir();
+ if (!targetDirectory.exists()) {
+ throw new IOException("Cannot create target directory "
+ + targetDirectory);
+ }
+
+ FileInputStream in = new FileInputStream(zipFile);
+ try {
+ ZipInputStream zipStream = new ZipInputStream(in);
+ try {
+ for (ZipEntry entry = zipStream.getNextEntry(); entry != null; entry = zipStream
+ .getNextEntry()) {
+ File file = new File(targetDirectory, entry.getName());
+ if (entry.isDirectory()) {
+ file.mkdirs();
+ } else {
+ IOUtils.write(zipStream, file);
+ count++;
+ }
+ }
+ } finally {
+ zipStream.close();
+ }
+ } finally {
+ in.close();
+ }
+
+ return count;
+ }
+
/**
* Write the {@link String} content to {@link File}.
*
dir.mkdirs();
}
- FileWriter writerVersion = new FileWriter(new File(dir, filename));
+ writeSmallFile(new File(dir, filename), content);
+ }
+
+ /**
+ * Write the {@link String} content to {@link File}.
+ *
+ * @param file
+ * the {@link File} to write
+ * @param content
+ * the content
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ public static void writeSmallFile(File file, String content)
+ throws IOException {
+ FileOutputStream out = new FileOutputStream(file);
try {
- writerVersion.write(content);
+ out.write(StringUtils.getBytes(content));
} finally {
- writerVersion.close();
+ out.close();
}
}
* in case of I/O error
*/
public static String readSmallStream(InputStream stream) throws IOException {
- // do NOT close the reader, or the related stream will be closed, too
- // reader.close();
- BufferedReader reader = new BufferedReader(
- new InputStreamReader(stream));
-
- StringBuilder builder = new StringBuilder();
- for (String line = reader.readLine(); line != null; line = reader
- .readLine()) {
- builder.append(line);
- builder.append("\n");
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ try {
+ write(stream, out);
+ return out.toString("UTF-8");
+ } finally {
+ out.close();
}
-
- return builder.toString();
}
/**
return errorAcc;
}
+ /**
+ * Open the resource next to the given {@link Class}.
+ *
+ * @param location
+ * the location where to look for the resource
+ * @param name
+ * the resource name (only the filename, no path)
+ *
+ * @return the opened resource if found, NULL if not
+ */
+ public static InputStream openResource(
+ @SuppressWarnings("rawtypes") Class location, String name) {
+ String loc = location.getName().replace(".", "/")
+ .replaceAll("/[^/]*$", "/");
+ return openResource(loc + name);
+ }
+
/**
* Open the given /-separated resource (from the binary root).
*
* @param name
- * the resource name
+ * the resource name (the full path, with "/" as separator)
*
- * @return the opened resource if found, NLL if not
+ * @return the opened resource if found, NULL if not
*/
public static InputStream openResource(String name) {
ClassLoader loader = IOUtils.class.getClassLoader();
*/
public static InputStream forceResetableStream(InputStream in)
throws IOException {
- MarkableFileInputStream tmpIn = null;
- File tmp = null;
-
boolean resetable = in.markSupported();
if (resetable) {
try {
return in;
}
- tmp = File.createTempFile(".tmp-stream", ".tmp");
+ final File tmp = File.createTempFile(".tmp-stream.", ".tmp");
try {
write(in, tmp);
- tmpIn = new MarkableFileInputStream(new FileInputStream(tmp));
- return tmpIn;
- } finally {
- try {
- if (tmpIn != null) {
- tmpIn.close();
+ in.close();
+
+ return new MarkableFileInputStream(tmp) {
+ @Override
+ public void close() throws IOException {
+ try {
+ super.close();
+ } finally {
+ tmp.delete();
+ }
}
- } finally {
- tmp.delete();
- }
+ };
+ } catch (IOException e) {
+ tmp.delete();
+ throw e;
}
}
*/
public static byte[] toByteArray(InputStream in) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
- write(in, out);
-
- byte[] array = out.toByteArray();
- out.close();
+ try {
+ write(in, out);
+ return out.toByteArray();
+ } finally {
+ out.close();
+ }
+ }
- return array;
+ /**
+ * Convert the {@link File} into a byte array.
+ *
+ * @param file
+ * the input {@link File}
+ *
+ * @return the array
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ public static byte[] toByteArray(File file) throws IOException {
+ FileInputStream fis = new FileInputStream(file);
+ try {
+ return toByteArray(fis);
+ } finally {
+ fis.close();
+ }
}
}
git://git.nikiroo.be / fanfix.git / blobdiff