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 java.io.OutputStream;
+import java.io.Serializable;
import be.nikiroo.utils.streams.MarkableFileInputStream;
*
* @author niki
*/
-public class Image implements Closeable {
+public class Image implements Closeable, Serializable {
+ static private final long serialVersionUID = 1L;
+
static private File tempRoot;
static private TempFiles tmpRepository;
static private long count = 0;
}
}
- /**
- * Create a new {@link Image} from its Base64 representation.
- *
- * @param base64
- * the {@link Image} in Base64 format
- *
- * @throws IOException
- * in case of I/O error
- */
- public Image(String base64) throws IOException {
- this(Base64.decode(base64));
- }
-
/**
* Create a new {@link Image} from a stream.
*
}
/**
- * Generate an {@link InputStream} for this {@link Image}.
+ * 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.
* in case of I/O error
*/
public InputStream newInputStream() throws IOException {
- return new MarkableFileInputStream(new FileInputStream(data));
+ return new MarkableFileInputStream(data);
}
/**
}
}
- /**
- * Convert the given {@link Image} object into a Base64 representation of
- * the same {@link Image} object.
- * <p>
- * Note: if possible, prefer the {@link Image#newInputStream()} method, as
- * it can be more efficient.
- *
- * @return the Base64 representation
- */
- public String toBase64() {
- try {
- return StringUtils.base64(getData(), false);
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
-
/**
* Closing the {@link Image} will delete the associated temporary file on
* disk.
}
}
+ /**
+ * Write this {@link Image} for serialization purposes; that is, write the
+ * content of the backing temporary file.
+ *
+ * @param out
+ * the {@link OutputStream} to write to
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ private void writeObject(java.io.ObjectOutputStream out) throws IOException {
+ InputStream in = newInputStream();
+ try {
+ IOUtils.write(in, out);
+ } finally {
+ in.close();
+ }
+ }
+
+ /**
+ * Read an {@link Image} written by
+ * {@link Image#writeObject(java.io.ObjectOutputStream)}; that is, create a
+ * new temporary file with the saved content.
+ *
+ * @param in
+ * the {@link InputStream} to read from
+ * @throws IOException
+ * in case of I/O error
+ * @throws ClassNotFoundException
+ * will not be thrown by this method
+ */
+ @SuppressWarnings("unused")
+ private void readObject(java.io.ObjectInputStream in) throws IOException,
+ ClassNotFoundException {
+ data = getTemporaryFile();
+ IOUtils.write(in, data);
+ }
+
/**
* Change the temporary root directory used by the program.
* <p>