From 5221cf7f72655a6e27af81167a4a3f237750c7ca Mon Sep 17 00:00:00 2001 From: Niki Roo Date: Fri, 3 May 2019 10:42:29 +0200 Subject: [PATCH] limit API breakage --- changelog.md | 11 +- src/be/nikiroo/utils/Image.java | 57 ++++++++- src/be/nikiroo/utils/StringUtils.java | 174 +++++++++++++++++++++++++- 3 files changed, 230 insertions(+), 12 deletions(-) diff --git a/changelog.md b/changelog.md index 4223b1b..a2510be 100644 --- a/changelog.md +++ b/changelog.md @@ -6,13 +6,14 @@ - new: CryptUtils - new: streams classes - fix: IOUtils.readSmallStream and \n at the end -- fix: Base64 implementation changed -- change: serial: SSL -> CryptUtils -- change: markableFileInputStream moved to nikiroo.utils.streams -- change: break compat with package utils.server -- change: break compat with base64 methods in StringUtils (now it works correctly, too) +- fix: Base64 implementation changed, no strange errors anymore +- change: StringUtils.unzip64(String) now returns a byte[] (StringUtils.unzip64s(String) can be used instead) +- change: be.nikiroo.utils.markableFileInputStream moved to be.nikiroo.utils.streams (old class still present in @Deprecated state for now) +- change: serial: SSL -> CryptUtils (both are incompatible) +- change: break compat with package utils.serial (Objects) -- ServerString should still be compatible - change: TestLauncher is now "silent" by default (no exception details, see setDetails(true)) + ## Version 4.7.2 - fix: Downloader issue with caching (input was spent when returned the first time) diff --git a/src/be/nikiroo/utils/Image.java b/src/be/nikiroo/utils/Image.java index 2e9c9f8..64f7b5a 100644 --- a/src/be/nikiroo/utils/Image.java +++ b/src/be/nikiroo/utils/Image.java @@ -5,9 +5,12 @@ import java.io.Closeable; import java.io.File; import java.io.IOException; import java.io.InputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; import java.io.OutputStream; import java.io.Serializable; +import be.nikiroo.utils.streams.Base64InputStream; import be.nikiroo.utils.streams.MarkableFileInputStream; /** @@ -54,6 +57,24 @@ public class Image implements Closeable, Serializable { } } + /** + * Create an image from Base64 encoded data. + * + * @deprecated Please use {@link Image#Image(InputStream)} instead, with a + * {@link Base64InputStream} + * + * @param base64EncodedData + * the Base64 encoded data as a String + * + * @throws IOException + * in case of I/O error or badly formated Base64 + */ + @Deprecated + public Image(String base64EncodedData) throws IOException { + this(new Base64InputStream(new ByteArrayInputStream( + StringUtils.getBytes(base64EncodedData)), false)); + } + /** * Create a new {@link Image} from a stream. * @@ -89,12 +110,13 @@ public class Image implements Closeable, Serializable { /** * Read the actual image data, as a byte array. - *

- * Note: if possible, prefer the {@link Image#newInputStream()} method, as - * it can be more efficient. + * + * @deprecated if possible, prefer the {@link Image#newInputStream()} + * method, as it can be more efficient * * @return the image data */ + @Deprecated public byte[] getData() { try { InputStream in = newInputStream(); @@ -108,6 +130,30 @@ public class Image implements Closeable, Serializable { } } + /** + * Convert the given {@link Image} object into a Base64 representation of + * the same {@link Image} object. + * + * @deprecated Please use {@link Image#newInputStream()} instead, it is more + * efficient + * + * @return the Base64 representation + */ + @Deprecated + public String toBase64() { + try { + Base64InputStream stream = new Base64InputStream(newInputStream(), + true); + try { + return IOUtils.readSmallStream(stream); + } finally { + stream.close(); + } + } catch (IOException e) { + return null; + } + } + /** * Closing the {@link Image} will delete the associated temporary file on * disk. @@ -168,7 +214,7 @@ public class Image implements Closeable, Serializable { * @throws IOException * in case of I/O error */ - private void writeObject(java.io.ObjectOutputStream out) throws IOException { + private void writeObject(ObjectOutputStream out) throws IOException { InputStream in = newInputStream(); try { IOUtils.write(in, out); @@ -189,8 +235,7 @@ public class Image implements Closeable, Serializable { * @throws ClassNotFoundException * will not be thrown by this method */ - @SuppressWarnings("unused") - private void readObject(java.io.ObjectInputStream in) throws IOException, + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { data = getTemporaryFile(); IOUtils.write(in, data); diff --git a/src/be/nikiroo/utils/StringUtils.java b/src/be/nikiroo/utils/StringUtils.java index 8717364..f7548ae 100644 --- a/src/be/nikiroo/utils/StringUtils.java +++ b/src/be/nikiroo/utils/StringUtils.java @@ -14,6 +14,7 @@ import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.AbstractMap; import java.util.ArrayList; +import java.util.Arrays; import java.util.Date; import java.util.List; import java.util.Map.Entry; @@ -26,6 +27,7 @@ import org.unbescape.html.HtmlEscapeLevel; import org.unbescape.html.HtmlEscapeType; import be.nikiroo.utils.streams.Base64InputStream; +import be.nikiroo.utils.streams.Base64OutputStream; /** * This class offer some utilities based around {@link String}s. @@ -524,7 +526,7 @@ public class StringUtils { * @throws IOException * in case of I/O error */ - public static String zip64s(String data) throws IOException { + public static String zip64(String data) throws IOException { try { return zip64(getBytes(data)); } catch (UnsupportedEncodingException e) { @@ -963,4 +965,174 @@ public class StringUtils { return count > 2; } + + // Deprecated functions, please do not use // + + /** + * @deprecated please use {@link StringUtils#zip64(byte[])} or + * {@link StringUtils#base64(byte[])} instead. + * + * @param data + * the data to encode + * @param zip + * TRUE to zip it before Base64 encoding it, FALSE for Base64 + * encoding only + * + * @return the encoded data + * + * @throws IOException + * in case of I/O error + */ + @Deprecated + public static String base64(String data, boolean zip) throws IOException { + return base64(getBytes(data), zip); + } + + /** + * @deprecated please use {@link StringUtils#zip64(String)} or + * {@link StringUtils#base64(String)} instead. + * + * @param data + * the data to encode + * @param zip + * TRUE to zip it before Base64 encoding it, FALSE for Base64 + * encoding only + * + * @return the encoded data + * + * @throws IOException + * in case of I/O error + */ + @Deprecated + public static String base64(byte[] data, boolean zip) throws IOException { + if (zip) { + return zip64(data); + } + + Base64InputStream b64 = new Base64InputStream(new ByteArrayInputStream( + data), true); + try { + return IOUtils.readSmallStream(b64); + } finally { + b64.close(); + } + } + + /** + * @deprecated please use {@link Base64OutputStream} and + * {@link GZIPOutputStream} instead. + * + * @param breakLines + * NOT USED ANYMORE, it is always considered FALSE now + */ + @Deprecated + public static OutputStream base64(OutputStream data, boolean zip, + boolean breakLines) throws IOException { + OutputStream out = new Base64OutputStream(data); + if (zip) { + out = new java.util.zip.GZIPOutputStream(out); + } + + return out; + } + + /** + * Unconvert the given data from Base64 format back to a raw array of bytes. + *

+ * Will automatically detect zipped data and also uncompress it before + * returning, unless ZIP is false. + * + * @deprecated DO NOT USE ANYMORE (bad perf, will be dropped) + * + * @param data + * the data to unconvert + * @param zip + * TRUE to also uncompress the data from a GZIP format + * automatically; if set to FALSE, zipped data can be returned + * + * @return the raw data represented by the given Base64 {@link String}, + * optionally compressed with GZIP + * + * @throws IOException + * in case of I/O errors + */ + @Deprecated + public static byte[] unbase64(String data, boolean zip) throws IOException { + byte[] buffer = unbase64(data); + if (!zip) { + return buffer; + } + + try { + GZIPInputStream zipped = new GZIPInputStream( + new ByteArrayInputStream(buffer)); + try { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + try { + IOUtils.write(zipped, out); + return out.toByteArray(); + } finally { + out.close(); + } + } finally { + zipped.close(); + } + } catch (Exception e) { + return buffer; + } + } + + /** + * Unconvert the given data from Base64 format back to a raw array of bytes. + *

+ * Will automatically detect zipped data and also uncompress it before + * returning, unless ZIP is false. + * + * @deprecated DO NOT USE ANYMORE (bad perf, will be dropped) + * + * @param data + * the data to unconvert + * @param zip + * TRUE to also uncompress the data from a GZIP format + * automatically; if set to FALSE, zipped data can be returned + * + * @return the raw data represented by the given Base64 {@link String}, + * optionally compressed with GZIP + * + * @throws IOException + * in case of I/O errors + */ + @Deprecated + public static InputStream unbase64(InputStream data, boolean zip) + throws IOException { + return new ByteArrayInputStream(unbase64(IOUtils.readSmallStream(data), + zip)); + } + + /** + * @deprecated DO NOT USE ANYMORE (bad perf, will be dropped) + */ + @Deprecated + public static byte[] unbase64(byte[] data, int offset, int count, + boolean zip) throws IOException { + byte[] dataPart = Arrays.copyOfRange(data, offset, offset + count); + return unbase64(new String(dataPart, "UTF-8"), zip); + } + + /** + * @deprecated DO NOT USE ANYMORE (bad perf, will be dropped) + */ + @Deprecated + public static String unbase64s(String data, boolean zip) throws IOException { + return new String(unbase64(data, zip), "UTF-8"); + } + + /** + * @deprecated DO NOT USE ANYMORE (bad perf, will be dropped) + */ + @Deprecated + public static String unbase64s(byte[] data, int offset, int count, + boolean zip) throws IOException { + return new String(unbase64(data, offset, count, zip), "UTF-8"); + } } -- 2.27.0