Version 4.0.0: java.awt dependencies move

[nikiroo-utils.git] / src / be / nikiroo / utils / IOUtils.java

diff --git a/src/be/nikiroo/utils/IOUtils.java b/src/be/nikiroo/utils/IOUtils.java
index 09b0cb9f1cc989815f84f67a6ff1109fdc7097c8..f857850dea11db8d4185fd21ad226b86380cc034 100644 (file)
--- a/src/be/nikiroo/utils/IOUtils.java
+++ b/src/be/nikiroo/utils/IOUtils.java
@@ -1,13 +1,14 @@
 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.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
@@ -43,7 +44,7 @@ public class IOUtils {
         * 
         * @param in
         *            the data source
-        * @param target
+        * @param out
         *            the target {@link OutputStream}
         * 
         * @throws IOException
@@ -112,7 +113,7 @@ public class IOUtils {
         *            the source {@link File} (which can be a directory)
         * @param dest
         *            the destination <tt>.zip</tt> file
-        * @param srctIsRoot
+        * @param srcIsRoot
         *            FALSE if we need to add a {@link ZipEntry} for src, TRUE to
         *            add it at the root of the ZIP
         * 
@@ -173,17 +174,39 @@ public class IOUtils {
         *             in case of I/O error
         */
        public static String readSmallFile(File file) throws IOException {
-               BufferedReader reader = new BufferedReader(new FileReader(file));
+               InputStream stream = new FileInputStream(file);
                try {
-                       StringBuilder builder = new StringBuilder();
-                       for (String line = reader.readLine(); line != null; line = reader
-                                       .readLine()) {
-                               builder.append(line);
-                       }
-                       return builder.toString();
+                       return readSmallStream(stream);
                } finally {
-                       reader.close();
+                       stream.close();
+               }
+       }
+
+       /**
+        * Read the whole {@link InputStream} content into a {@link String}.
+        * 
+        * @param stream
+        *            the {@link InputStream}
+        * 
+        * @return the content
+        * 
+        * @throws IOException
+        *             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");
                }
+
+               return builder.toString();
        }
 
        /**
@@ -196,20 +219,97 @@ public class IOUtils {
         *            the target to delete
         */
        public static void deltree(File target) {
-               for (File file : target.listFiles()) {
-                       if (file.isDirectory()) {
+               File[] files = target.listFiles();
+               if (files != null) {
+                       for (File file : files) {
                                deltree(file);
-                       } else {
-                               if (!file.delete()) {
-                                       System.err.println("Cannot delete file: "
-                                                       + file.getAbsolutePath());
-                               }
                        }
                }
 
                if (!target.delete()) {
-                       System.err.println("Cannot delete file: "
-                                       + target.getAbsolutePath());
+                       System.err.println("Cannot delete: " + target.getAbsolutePath());
+               }
+       }
+
+       /**
+        * Open the given /-separated resource (from the binary root).
+        * 
+        * @param name
+        *            the resource name
+        * 
+        * @return the opened resource if found, NLL if not
+        */
+       public static InputStream openResource(String name) {
+               ClassLoader loader = IOUtils.class.getClassLoader();
+               if (loader == null) {
+                       loader = ClassLoader.getSystemClassLoader();
                }
+
+               return loader.getResourceAsStream(name);
+       }
+
+       /**
+        * Return a resetable {@link InputStream} from this stream, and reset it.
+        * 
+        * @param in
+        *            the input stream
+        * @return the resetable stream, which <b>may</b> be the same
+        * 
+        * @throws IOException
+        *             in case of I/O error
+        */
+       public static InputStream forceResetableStream(InputStream in)
+                       throws IOException {
+               MarkableFileInputStream tmpIn = null;
+               File tmp = null;
+
+               boolean resetable = in.markSupported();
+               if (resetable) {
+                       try {
+                               in.reset();
+                       } catch (IOException e) {
+                               resetable = false;
+                       }
+               }
+
+               if (resetable) {
+                       return in;
+               }
+
+               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();
+                               }
+                       } finally {
+                               tmp.delete();
+                       }
+               }
+       }
+
+       /**
+        * Convert the {@link InputStream} into a byte array.
+        * 
+        * @param in
+        *            the input stream
+        * 
+        * @return the array
+        * 
+        * @throws IOException
+        *             in case of I/O error
+        */
+       public static byte[] toByteArray(InputStream in) throws IOException {
+               ByteArrayOutputStream out = new ByteArrayOutputStream();
+               write(in, out);
+
+               byte[] array = out.toByteArray();
+               out.close();
+
+               return array;
        }
 }