code cleanup, fix for ReplaceInputStream

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

diff --git a/src/be/nikiroo/utils/Image.java b/src/be/nikiroo/utils/Image.java
index 4eacdac8f0b15ae08bb09767a0145032080d9965..58b1f5aeac05f71370365ac9c3a562f70f722797 100644 (file)
--- a/src/be/nikiroo/utils/Image.java
+++ b/src/be/nikiroo/utils/Image.java
@@ -3,16 +3,18 @@ package be.nikiroo.utils;
 import java.io.ByteArrayInputStream;
 import java.io.Closeable;
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 
+import be.nikiroo.utils.streams.MarkableFileInputStream;
+
 /**
  * This class represents an image data.
  * 
  * @author niki
  */
 public class Image implements Closeable {
+       static private File tempRoot;
        static private TempFiles tmpRepository;
        static private long count = 0;
        static private Object lock = new Object();
@@ -49,40 +51,49 @@ public class Image implements Closeable {
        }
 
        /**
-        * Create a new {@link Image} from its Base64 representation.
+        * Create a new {@link Image} from a stream.
         * 
-        * @param base64
-        *            the {@link Image} in Base64 format
+        * @param in
+        *            the stream
         * 
         * @throws IOException
         *             in case of I/O error
         */
-       public Image(String base64) throws IOException {
-               this(Base64.decode(base64));
+       public Image(InputStream in) throws IOException {
+               data = getTemporaryFile();
+               IOUtils.write(in, data);
        }
 
        /**
-        * Create a new {@link Image} from a stream.
+        * Generate an {@link InputStream} that you can {@link InputStream#reset()}
+        * for this {@link Image}.
+        * <p>
+        * This {@link InputStream} will (always) be a new one, and <b>you</b> are
+        * responsible for it.
+        * <p>
+        * Note: take care that the {@link InputStream} <b>must not</b> live past
+        * the {@link Image} life time!
         * 
-        * @param in
-        *            the stream
+        * @return the stream
         * 
         * @throws IOException
         *             in case of I/O error
         */
-       public Image(InputStream in) throws IOException {
-               data = getTemporaryFile();
-               IOUtils.write(in, data);
+       public InputStream newInputStream() throws IOException {
+               return new MarkableFileInputStream(data);
        }
 
        /**
         * <b>Read</b> the actual image data, as a byte array.
+        * <p>
+        * Note: if possible, prefer the {@link Image#newInputStream()} method, as
+        * it can be more efficient.
         * 
         * @return the image data
         */
        public byte[] getData() {
                try {
-                       FileInputStream in = new FileInputStream(data);
+                       InputStream in = newInputStream();
                        try {
                                return IOUtils.toByteArray(in);
                        } finally {
@@ -93,16 +104,6 @@ public class Image implements Closeable {
                }
        }
 
-       /**
-        * Convert the given {@link Image} object into a Base64 representation of
-        * the same {@link Image} object.
-        * 
-        * @return the Base64 representation
-        */
-       public String toBase64() {
-               return Base64.encodeBytes(getData());
-       }
-
        /**
         * Closing the {@link Image} will delete the associated temporary file on
         * disk.
@@ -143,7 +144,7 @@ public class Image implements Closeable {
        private File getTemporaryFile() throws IOException {
                synchronized (lock) {
                        if (tmpRepository == null) {
-                               tmpRepository = new TempFiles("images");
+                               tmpRepository = new TempFiles(tempRoot, "images");
                                count = 0;
                        }
 
@@ -152,4 +153,23 @@ public class Image implements Closeable {
                        return tmpRepository.createTempFile("image");
                }
        }
+
+       /**
+        * Change the temporary root directory used by the program.
+        * <p>
+        * Caution: the directory will be <b>owned</b> by the system, all its files
+        * now belong to us (and will most probably be deleted).
+        * <p>
+        * Note: it may take some time until the new temporary root is used, we
+        * first need to make sure the previous one is not used anymore (i.e., we
+        * must reach a point where no unclosed {@link Image} remains in memory) to
+        * switch the temporary root.
+        * 
+        * @param root
+        *            the new temporary root, which will be <b>owned</b> by the
+        *            system
+        */
+       public static void setTemporaryFilesRoot(File root) {
+               tempRoot = root;
+       }
 }