limit API breakage

diff --git a/changelog.md b/changelog.md
index 4223b1be884f53447cf14bcc53748238610d6b19..a2510be06470fe8c2535bc47804c7b29a764a64e 100644 (file)
--- 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 2e9c9f83a39bfd4fcdeef8d351071d8284e9af61..64f7b5a18f583ca2df5ebb055f3ac081f36ea9eb 100644 (file)
--- 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 {
 
        /**
         * <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.
+        * 
+        * @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 8717364c72ce055352aa810925bdd662c17ba458..f7548aecca717c19aff3b0c60db338f5ad0fe1df 100644 (file)
--- 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.
+        * <p>
+        * 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.
+        * <p>
+        * 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");
+       }
 }