package be.nikiroo.utils;
-import java.awt.Image;
-import java.awt.geom.AffineTransform;
-import java.awt.image.AffineTransformOp;
-import java.awt.image.BufferedImage;
-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.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 javax.imageio.ImageIO;
+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 in
* the data source
- * @param target
+ * @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;
}
/**
}
zip.putNextEntry(new ZipEntry(base + "/"));
}
- for (File file : target.listFiles()) {
- zip(zip, base, file, false);
+
+ File[] files = target.listFiles();
+ if (files != null) {
+ for (File file : files) {
+ zip(zip, base, file, false);
+ }
}
} else {
if (base == null || base.isEmpty()) {
* 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
*
}
}
+ /**
+ * 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 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 {
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ try {
+ write(stream, out);
+ return out.toString("UTF-8");
+ } finally {
+ out.close();
}
}
* Recursively delete the given {@link File}, which may of course also be a
* directory.
* <p>
- * Will silently continue in case of error.
+ * Will either silently continue or throw an exception in case of error,
+ * depending upon the parameters.
*
* @param target
* the target to delete
+ * @param exception
+ * TRUE to throw an {@link IOException} in case of error, FALSE
+ * to silently continue
+ *
+ * @return TRUE if all files were deleted, FALSE if an error occurred
+ *
+ * @throws IOException
+ * if an error occurred and the parameters allow an exception to
+ * be thrown
*/
- public static void deltree(File target) {
- for (File file : target.listFiles()) {
- if (file.isDirectory()) {
- deltree(file);
- } else {
- if (!file.delete()) {
- System.err.println("Cannot delete file: "
- + file.getAbsolutePath());
- }
+ public static boolean deltree(File target, boolean exception)
+ throws IOException {
+ List<File> list = deltree(target, null);
+ if (exception && !list.isEmpty()) {
+ StringBuilder slist = new StringBuilder();
+ for (File file : list) {
+ slist.append("\n").append(file.getPath());
}
- }
- if (!target.delete()) {
- System.err.println("Cannot delete file: "
- + target.getAbsolutePath());
+ throw new IOException("Cannot delete all the files from: <" //
+ + target + ">:" + slist.toString());
}
+
+ return list.isEmpty();
}
/**
- * Convert the given {@link InputStream} (which should allow calls to
- * {@link InputStream#reset() for better perfs}) into an {@link Image}
- * object, respecting the EXIF transformations if any.
- *
- * @param in
- * the 'resetable' {@link InputStream}
+ * Recursively delete the given {@link File}, which may of course also be a
+ * directory.
+ * <p>
+ * Will silently continue in case of error.
*
- * @return the {@link Image} object
+ * @param target
+ * the target to delete
*
- * @throws IOException
- * in case of IO error
+ * @return TRUE if all files were deleted, FALSE if an error occurred
*/
- static public BufferedImage toImage(InputStream in) throws IOException {
- MarkableFileInputStream tmpIn = null;
- File tmp = null;
- try {
- in.reset();
- } catch (IOException e) {
- tmp = File.createTempFile("fanfic-tmp-image", ".tmp");
- tmp.deleteOnExit();
- IOUtils.write(in, tmp);
- tmpIn = new MarkableFileInputStream(new FileInputStream(tmp));
- }
+ public static boolean deltree(File target) {
+ return deltree(target, null).isEmpty();
+ }
- int orientation;
- try {
- orientation = getExifTransorm(in);
- } catch (Exception e) {
- // no EXIF transform, ok
- orientation = -1;
+ /**
+ * Recursively delete the given {@link File}, which may of course also be a
+ * directory.
+ * <p>
+ * Will collect all {@link File} that cannot be deleted in the given
+ * accumulator.
+ *
+ * @param target
+ * the target to delete
+ * @param errorAcc
+ * the accumulator to use for errors, or NULL to create a new one
+ *
+ * @return the errors accumulator
+ */
+ public static List<File> deltree(File target, List<File> errorAcc) {
+ if (errorAcc == null) {
+ errorAcc = new ArrayList<File>();
}
- in.reset();
- BufferedImage image = ImageIO.read(in);
-
- if (image == null) {
- if (tmp != null) {
- tmp.delete();
- tmpIn.close();
+ File[] files = target.listFiles();
+ if (files != null) {
+ for (File file : files) {
+ errorAcc = deltree(file, errorAcc);
}
- throw new IOException("Failed to convert input to image");
}
- // Note: this code has been found on internet;
- // thank you anonymous coder.
- int width = image.getWidth();
- int height = image.getHeight();
- AffineTransform affineTransform = new AffineTransform();
-
- switch (orientation) {
- case 1:
- affineTransform = null;
- break;
- case 2: // Flip X
- affineTransform.scale(-1.0, 1.0);
- affineTransform.translate(-width, 0);
- break;
- case 3: // PI rotation
- affineTransform.translate(width, height);
- affineTransform.rotate(Math.PI);
- break;
- case 4: // Flip Y
- affineTransform.scale(1.0, -1.0);
- affineTransform.translate(0, -height);
- break;
- case 5: // - PI/2 and Flip X
- affineTransform.rotate(-Math.PI / 2);
- affineTransform.scale(-1.0, 1.0);
- break;
- case 6: // -PI/2 and -width
- affineTransform.translate(height, 0);
- affineTransform.rotate(Math.PI / 2);
- break;
- case 7: // PI/2 and Flip
- affineTransform.scale(-1.0, 1.0);
- affineTransform.translate(-height, 0);
- affineTransform.translate(0, width);
- affineTransform.rotate(3 * Math.PI / 2);
- break;
- case 8: // PI / 2
- affineTransform.translate(0, width);
- affineTransform.rotate(3 * Math.PI / 2);
- break;
- default:
- affineTransform = null;
- break;
+ if (!target.delete()) {
+ errorAcc.add(target);
}
- if (affineTransform != null) {
- AffineTransformOp affineTransformOp = new AffineTransformOp(
- affineTransform, AffineTransformOp.TYPE_BILINEAR);
-
- BufferedImage transformedImage = new BufferedImage(width, height,
- image.getType());
- transformedImage = affineTransformOp
- .filter(image, transformedImage);
+ return errorAcc;
+ }
- image = transformedImage;
- }
- //
+ /**
+ * 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);
+ }
- if (tmp != null) {
- tmp.delete();
- tmpIn.close();
+ /**
+ * Open the given /-separated resource (from the binary root).
+ *
+ * @param name
+ * the resource name (the full path, with "/" as separator)
+ *
+ * @return the opened resource if found, NULL if not
+ */
+ public static InputStream openResource(String name) {
+ ClassLoader loader = IOUtils.class.getClassLoader();
+ if (loader == null) {
+ loader = ClassLoader.getSystemClassLoader();
}
- return image;
+ return loader.getResourceAsStream(name);
}
/**
- * Return the EXIF transformation flag of this image if any.
- *
- * <p>
- * Note: this code has been found on internet; thank you anonymous coder.
- * </p>
+ * Return a resetable {@link InputStream} from this stream, and reset it.
*
* @param in
- * the data {@link InputStream}
- *
- * @return the transformation flag if any
+ * the input stream
+ * @return the resetable stream, which <b>may</b> be the same
*
* @throws IOException
- * in case of IO error
+ * in case of I/O error
*/
- static private int getExifTransorm(InputStream in) throws IOException {
- int[] exif_data = new int[100];
- int set_flag = 0;
- int is_motorola = 0;
-
- /* Read File head, check for JPEG SOI + Exif APP1 */
- for (int i = 0; i < 4; i++)
- exif_data[i] = in.read();
-
- if (exif_data[0] != 0xFF || exif_data[1] != 0xD8
- || exif_data[2] != 0xFF || exif_data[3] != 0xE1)
- return -2;
-
- /* Get the marker parameter length count */
- int length = (in.read() << 8 | in.read());
-
- /* Length includes itself, so must be at least 2 */
- /* Following Exif data length must be at least 6 */
- if (length < 8)
- return -1;
- length -= 8;
- /* Read Exif head, check for "Exif" */
- for (int i = 0; i < 6; i++)
- exif_data[i] = in.read();
-
- if (exif_data[0] != 0x45 || exif_data[1] != 0x78
- || exif_data[2] != 0x69 || exif_data[3] != 0x66
- || exif_data[4] != 0 || exif_data[5] != 0)
- return -1;
-
- /* Read Exif body */
- length = length > exif_data.length ? exif_data.length : length;
- for (int i = 0; i < length; i++)
- exif_data[i] = in.read();
-
- if (length < 12)
- return -1; /* Length of an IFD entry */
-
- /* Discover byte order */
- if (exif_data[0] == 0x49 && exif_data[1] == 0x49)
- is_motorola = 0;
- else if (exif_data[0] == 0x4D && exif_data[1] == 0x4D)
- is_motorola = 1;
- else
- return -1;
-
- /* Check Tag Mark */
- if (is_motorola == 1) {
- if (exif_data[2] != 0)
- return -1;
- if (exif_data[3] != 0x2A)
- return -1;
- } else {
- if (exif_data[3] != 0)
- return -1;
- if (exif_data[2] != 0x2A)
- return -1;
+ public static InputStream forceResetableStream(InputStream in)
+ throws IOException {
+ boolean resetable = in.markSupported();
+ if (resetable) {
+ try {
+ in.reset();
+ } catch (IOException e) {
+ resetable = false;
+ }
}
- /* Get first IFD offset (offset to IFD0) */
- int offset;
- if (is_motorola == 1) {
- if (exif_data[4] != 0)
- return -1;
- if (exif_data[5] != 0)
- return -1;
- offset = exif_data[6];
- offset <<= 8;
- offset += exif_data[7];
- } else {
- if (exif_data[7] != 0)
- return -1;
- if (exif_data[6] != 0)
- return -1;
- offset = exif_data[5];
- offset <<= 8;
- offset += exif_data[4];
+ if (resetable) {
+ return in;
}
- if (offset > length - 2)
- return -1; /* check end of data segment */
-
- /* Get the number of directory entries contained in this IFD */
- int number_of_tags;
- if (is_motorola == 1) {
- number_of_tags = exif_data[offset];
- number_of_tags <<= 8;
- number_of_tags += exif_data[offset + 1];
- } else {
- number_of_tags = exif_data[offset + 1];
- number_of_tags <<= 8;
- number_of_tags += exif_data[offset];
- }
- if (number_of_tags == 0)
- return -1;
- offset += 2;
-
- /* Search for Orientation Tag in IFD0 */
- for (;;) {
- if (offset > length - 12)
- return -1; /* check end of data segment */
- /* Get Tag number */
- int tagnum;
- if (is_motorola == 1) {
- tagnum = exif_data[offset];
- tagnum <<= 8;
- tagnum += exif_data[offset + 1];
- } else {
- tagnum = exif_data[offset + 1];
- tagnum <<= 8;
- tagnum += exif_data[offset];
- }
- if (tagnum == 0x0112)
- break; /* found Orientation Tag */
- if (--number_of_tags == 0)
- return -1;
- offset += 12;
+
+ final File tmp = File.createTempFile(".tmp-stream.", ".tmp");
+ try {
+ write(in, tmp);
+ in.close();
+
+ return new MarkableFileInputStream(tmp) {
+ @Override
+ public void close() throws IOException {
+ try {
+ super.close();
+ } finally {
+ tmp.delete();
+ }
+ }
+ };
+ } catch (IOException e) {
+ tmp.delete();
+ throw e;
}
+ }
- /* Get the Orientation value */
- if (is_motorola == 1) {
- if (exif_data[offset + 8] != 0)
- return -1;
- set_flag = exif_data[offset + 9];
- } else {
- if (exif_data[offset + 9] != 0)
- return -1;
- set_flag = exif_data[offset + 8];
+ /**
+ * 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();
+ try {
+ write(in, out);
+ return out.toByteArray();
+ } finally {
+ out.close();
}
- if (set_flag > 8)
- return -1;
+ }
- return set_flag;
+ /**
+ * 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