X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Futils%2FStringUtils.java;h=8717364c72ce055352aa810925bdd662c17ba458;hb=f8147a0ee57317e96d9ff0bf19573f7168d0354c;hp=1884c21ff47a98fce6864c0c6a7c801727f0cb05;hpb=a359464fcf59af8abc6f69ae0e88e42adc6018df;p=nikiroo-utils.git diff --git a/src/be/nikiroo/utils/StringUtils.java b/src/be/nikiroo/utils/StringUtils.java index 1884c21..8717364 100644 --- a/src/be/nikiroo/utils/StringUtils.java +++ b/src/be/nikiroo/utils/StringUtils.java @@ -1,6 +1,7 @@ package be.nikiroo.utils; import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; @@ -16,13 +17,16 @@ import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Map.Entry; -import java.util.Scanner; import java.util.regex.Pattern; +import java.util.zip.GZIPInputStream; +import java.util.zip.GZIPOutputStream; import org.unbescape.html.HtmlEscape; import org.unbescape.html.HtmlEscapeLevel; import org.unbescape.html.HtmlEscapeType; +import be.nikiroo.utils.streams.Base64InputStream; + /** * This class offer some utilities based around {@link String}s. * @@ -428,7 +432,7 @@ public class StringUtils { static public String getMd5Hash(String input) { try { MessageDigest md = MessageDigest.getInstance("MD5"); - md.update(input.getBytes("UTF-8")); + md.update(getBytes(input)); byte byteData[] = md.digest(); StringBuffer hexString = new StringBuffer(); @@ -442,8 +446,6 @@ public class StringUtils { return hexString.toString(); } catch (NoSuchAlgorithmException e) { return input; - } catch (UnsupportedEncodingException e) { - return input; } } @@ -514,88 +516,96 @@ public class StringUtils { /** * Zip the data and then encode it into Base64. * - * @deprecated use {@link StringUtils#base64(byte[], boolean)} with the - * correct parameter instead - * * @param data * the data * * @return the Base64 zipped version + * + * @throws IOException + * in case of I/O error */ - @Deprecated - public static String zip64(String data) { + public static String zip64s(String data) throws IOException { try { - return Base64.encodeBytes(data.getBytes("UTF-8"), Base64.GZIP); - } catch (IOException e) { + return zip64(getBytes(data)); + } catch (UnsupportedEncodingException e) { + // All conforming JVM are required to support UTF-8 e.printStackTrace(); return null; } } /** - * Unconvert from Base64 then unzip the content. - * - * @deprecated use {@link StringUtils#unbase64s(String, boolean)} with the - * correct parameter instead + * Zip the data and then encode it into Base64. * * @param data - * the data in Base64 format + * the data * - * @return the raw data + * @return the Base64 zipped version * * @throws IOException * in case of I/O error */ - @Deprecated - public static String unzip64(String data) throws IOException { - ByteArrayInputStream in = new ByteArrayInputStream(Base64.decode(data, - Base64.GZIP)); + public static String zip64(byte[] data) throws IOException { + // 1. compress + ByteArrayOutputStream bout = new ByteArrayOutputStream(); + try { + OutputStream out = new GZIPOutputStream(bout); + try { + out.write(data); + } finally { + out.close(); + } + } finally { + data = bout.toByteArray(); + bout.close(); + } - Scanner scan = new Scanner(in); - scan.useDelimiter("\\A"); + // 2. base64 + InputStream in = new ByteArrayInputStream(data); try { - return scan.next(); + in = new Base64InputStream(in, true); + return new String(IOUtils.toByteArray(in), "UTF-8"); } finally { - scan.close(); + in.close(); } } /** - * Convert the given data to Base64 format. + * Unconvert from Base64 then unzip the content, which is assumed to be a + * String. * * @param data - * the data to convert - * @param zip - * TRUE to also compress the data in GZIP format; remember that - * compressed and not-compressed content are different; you need - * to know which is which when decoding + * the data in Base64 format * - * @return the Base64 {@link String} representation of the data + * @return the raw data * * @throws IOException - * in case of I/O errors + * in case of I/O error */ - public static String base64(String data, boolean zip) throws IOException { - return base64(data.getBytes("UTF-8"), zip); + public static String unzip64s(String data) throws IOException { + return new String(unzip64(data), "UTF-8"); } /** - * Convert the given data to Base64 format. + * Unconvert from Base64 then unzip the content. * * @param data - * the data to convert - * @param zip - * TRUE to also compress the data in GZIP format; remember that - * compressed and not-compressed content are different; you need - * to know which is which when decoding + * the data in Base64 format * - * @return the Base64 {@link String} representation of the data + * @return the raw data * * @throws IOException - * in case of I/O errors + * in case of I/O error */ - public static String base64(byte[] data, boolean zip) throws IOException { - return Base64.encodeBytes(data, zip ? Base64.GZIP : Base64.NO_OPTIONS); + public static byte[] unzip64(String data) throws IOException { + InputStream in = new Base64InputStream(new ByteArrayInputStream( + getBytes(data)), false); + try { + in = new GZIPInputStream(in); + return IOUtils.toByteArray(in); + } finally { + in.close(); + } } /** @@ -603,29 +613,14 @@ public class StringUtils { * * @param data * the data to convert - * @param zip - * TRUE to also uncompress the data from a GZIP format; take care - * about this flag, as it could easily cause errors in the - * returned content or an {@link IOException} - * @param breakLines - * TRUE to break lines on every 76th character * * @return the Base64 {@link String} representation of the data * * @throws IOException * in case of I/O errors */ - public static OutputStream base64(OutputStream data, boolean zip, - boolean breakLines) throws IOException { - OutputStream out = new Base64.OutputStream(data, - breakLines ? Base64.DO_BREAK_LINES & Base64.ENCODE - : Base64.ENCODE); - - if (zip) { - out = new java.util.zip.GZIPOutputStream(out); - } - - return out; + public static String base64(String data) throws IOException { + return base64(getBytes(data)); } /** @@ -633,26 +628,20 @@ public class StringUtils { * * @param data * the data to convert - * @param zip - * TRUE to also uncompress the data from a GZIP format; take care - * about this flag, as it could easily cause errors in the - * returned content or an {@link IOException} - * @param breakLines - * TRUE to break lines on every 76th character * * @return the Base64 {@link String} representation of the data * * @throws IOException * in case of I/O errors */ - public static InputStream base64(InputStream data, boolean zip, - boolean breakLines) throws IOException { - if (zip) { - data = new java.util.zip.GZIPInputStream(data); + public static String base64(byte[] data) throws IOException { + Base64InputStream in = new Base64InputStream(new ByteArrayInputStream( + data), true); + try { + return new String(IOUtils.toByteArray(in), "UTF-8"); + } finally { + in.close(); } - - return new Base64.InputStream(data, breakLines ? Base64.DO_BREAK_LINES - & Base64.ENCODE : Base64.ENCODE); } /** @@ -660,103 +649,202 @@ public class StringUtils { * * @param data * the data to unconvert - * @param zip - * TRUE to also uncompress the data from a GZIP format; take care - * about this flag, as it could easily cause errors in the - * returned content or an {@link IOException} * * @return the raw data represented by the given Base64 {@link String}, - * optionally compressed with GZIP * * @throws IOException * in case of I/O errors */ - public static byte[] unbase64(String data, boolean zip) throws IOException { - return Base64.decode(data, zip ? Base64.GZIP : Base64.NO_OPTIONS); + public static byte[] unbase64(String data) throws IOException { + Base64InputStream in = new Base64InputStream(new ByteArrayInputStream( + getBytes(data)), false); + try { + return IOUtils.toByteArray(in); + } finally { + in.close(); + } } /** - * Unconvert the given data from Base64 format back to a raw array of bytes. + * Unonvert the given data from Base64 format back to a {@link String}. * * @param data * the data to unconvert - * @param zip - * TRUE to also uncompress the data from a GZIP format; take care - * about this flag, as it could easily cause errors in the - * returned content or an {@link IOException} - * @param breakLines - * TRUE to break lines on every 76th character * - * @return the raw data represented by the given Base64 {@link String} + * @return the {@link String} represented by the given Base64 {@link String} * * @throws IOException * in case of I/O errors */ - public static OutputStream unbase64(OutputStream data, boolean zip, - boolean breakLines) throws IOException { - OutputStream out = new Base64.OutputStream(data, - breakLines ? Base64.DO_BREAK_LINES & Base64.ENCODE - : Base64.ENCODE); + public static String unbase64s(String data) throws IOException { + return new String(unbase64(data), "UTF-8"); + } + + /** + * Return a display {@link String} for the given value, which can be + * suffixed with "k" or "M" depending upon the number, if it is big enough. + *

+ *

+ * Examples: + *

+ * + * @param value + * the value to convert + * + * @return the display value + */ + public static String formatNumber(long value) { + return formatNumber(value, 0); + } + + /** + * Return a display {@link String} for the given value, which can be + * suffixed with "k" or "M" depending upon the number, if it is big enough. + *

+ * Examples (assuming decimalPositions = 1): + *

+ * + * @param value + * the value to convert + * @param decimalPositions + * the number of decimal positions to keep + * + * @return the display value + */ + public static String formatNumber(long value, int decimalPositions) { + long userValue = value; + String suffix = ""; + long mult = 1; + + if (value >= 1000000000l) { + mult = 1000000000l; + userValue = value / 1000000000l; + suffix = " G"; + } else if (value >= 1000000l) { + mult = 1000000l; + userValue = value / 1000000l; + suffix = " M"; + } else if (value >= 1000l) { + mult = 1000l; + userValue = value / 1000l; + suffix = " k"; + } + + String deci = ""; + if (decimalPositions > 0) { + deci = Long.toString(value % mult); + int size = Long.toString(mult).length() - 1; + while (deci.length() < size) { + deci = "0" + deci; + } - if (zip) { - out = new java.util.zip.GZIPOutputStream(out); + deci = deci.substring(0, Math.min(decimalPositions, deci.length())); + while (deci.length() < decimalPositions) { + deci += "0"; + } + + deci = "." + deci; } - return out; + return Long.toString(userValue) + deci + suffix; } /** - * Unconvert the given data from Base64 format back to a raw array of bytes. + * The reverse operation to {@link StringUtils#formatNumber(long)}: it will + * read a "display" number that can contain a "M" or "k" suffix and return + * the full value. + *

+ * Of course, the conversion to and from display form is lossy (example: + * 6870 to "6.5k" to 6500). * - * @param data - * the data to unconvert - * @param zip - * TRUE to also uncompress the data from a GZIP format; take care - * about this flag, as it could easily cause errors in the - * returned content or an {@link IOException} - * @param breakLines - * TRUE to break lines on every 76th character + * @param value + * the value in display form with possible "M" and "k" suffixes, + * can be NULL * - * @return the raw data represented by the given Base64 {@link String} + * @return the value as a number, or 0 if not possible to convert + */ + public static long toNumber(String value) { + return toNumber(value, 0l); + } + + /** + * The reverse operation to {@link StringUtils#formatNumber(long)}: it will + * read a "display" number that can contain a "M" or "k" suffix and return + * the full value. + *

+ * Of course, the conversion to and from display form is lossy (example: + * 6870 to "6.5k" to 6500). * - * @throws IOException - * in case of I/O errors + * @param value + * the value in display form with possible "M" and "k" suffixes, + * can be NULL + * @param def + * the default value if it is not possible to convert the given + * value to a number + * + * @return the value as a number, or 0 if not possible to convert */ - public static InputStream unbase64(InputStream data, boolean zip, - boolean breakLines) throws IOException { - if (zip) { - data = new java.util.zip.GZIPInputStream(data); + public static long toNumber(String value, long def) { + long count = def; + if (value != null) { + value = value.trim().toLowerCase(); + try { + long mult = 1; + if (value.endsWith("g")) { + value = value.substring(0, value.length() - 1).trim(); + mult = 1000000000; + } else if (value.endsWith("m")) { + value = value.substring(0, value.length() - 1).trim(); + mult = 1000000; + } else if (value.endsWith("k")) { + value = value.substring(0, value.length() - 1).trim(); + mult = 1000; + } + + long deci = 0; + if (value.contains(".")) { + String[] tab = value.split("\\."); + if (tab.length != 2) { + throw new NumberFormatException(value); + } + double decimal = Double.parseDouble("0." + + tab[tab.length - 1]); + deci = ((long) (mult * decimal)); + value = tab[0]; + } + count = mult * Long.parseLong(value) + deci; + } catch (Exception e) { + } } - return new Base64.InputStream(data, breakLines ? Base64.DO_BREAK_LINES - & Base64.ENCODE : Base64.ENCODE); + return count; } /** - * Unonvert the given data from Base64 format back to a {@link String}. + * Return the bytes array representation of the given {@link String} in + * UTF-8. * - * @param data - * the data to unconvert - * @param zip - * TRUE to also uncompress the data from a GZIP format; take care - * about this flag, as it could easily cause errors in the - * returned content or an {@link IOException} - * - * @return the {@link String} represented by the given Base64 {@link String} - * , optionally compressed with GZIP - * - * @throws IOException - * in case of I/O errors + * @param str + * the {@link String} to transform into bytes + * @return the content in bytes */ - public static String unbase64s(String data, boolean zip) throws IOException { - ByteArrayInputStream in = new ByteArrayInputStream(unbase64(data, zip)); - - Scanner scan = new Scanner(in, "UTF-8"); - scan.useDelimiter("\\A"); + static public byte[] getBytes(String str) { try { - return scan.next(); - } finally { - scan.close(); + return str.getBytes("UTF-8"); + } catch (UnsupportedEncodingException e) { + // All conforming JVM must support UTF-8 + e.printStackTrace(); + return null; } }