+ * Precise to the second. * * @param time - * the time in milliseconds + * the specified number of milliseconds since the standard base + * time known as "the epoch", namely January 1, 1970, 00:00:00 + * GMT * * @return the time as a {@link String} */ @@ -185,422 +395,669 @@ public class StringUtils { } /** - * Convert between time as a {@link String} to milliseconds in a "static" + * Convert between the time as a {@link String} to milliseconds in a "fixed" * way (to exchange data over the wire, for instance). + *
+ * Precise to the second. * - * @param time + * @param displayTime * the time as a {@link String} * - * @return the time in milliseconds + * @return the number of milliseconds since the standard base time known as + * "the epoch", namely January 1, 1970, 00:00:00 GMT, or -1 in case + * of error + * + * @throws ParseException + * in case of parse error */ - static public long toTime(String display) { + static public long toTime(String displayTime) throws ParseException { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + return sdf.parse(displayTime).getTime(); + } + + /** + * Return a hash of the given {@link String}. + * + * @param input + * the input data + * + * @return the hash + */ + static public String getMd5Hash(String input) { try { - return sdf.parse(display).getTime(); - } catch (ParseException e) { - return -1; + MessageDigest md = MessageDigest.getInstance("MD5"); + md.update(input.getBytes("UTF-8")); + byte byteData[] = md.digest(); + + StringBuffer hexString = new StringBuffer(); + for (int i = 0; i < byteData.length; i++) { + String hex = Integer.toHexString(0xff & byteData[i]); + if (hex.length() == 1) + hexString.append('0'); + hexString.append(hex); + } + + return hexString.toString(); + } catch (NoSuchAlgorithmException e) { + return input; + } catch (UnsupportedEncodingException e) { + return input; } } /** - * Convert the given {@link Image} object into a Base64 representation of - * the same {@link Image}. object. + * Remove the HTML content from the given input, and un-html-ize the rest. + * + * @param html + * the HTML-encoded content * - * @param image - * the {@link Image} object to convert + * @return the HTML-free equivalent content + */ + public static String unhtml(String html) { + StringBuilder builder = new StringBuilder(); + + int inTag = 0; + for (char car : html.toCharArray()) { + if (car == '<') { + inTag++; + } else if (car == '>') { + inTag--; + } else if (inTag <= 0) { + builder.append(car); + } + } + + char nbsp = 'Â '; // non-breakable space (a special char) + char space = ' '; + return HtmlEscape.unescapeHtml(builder.toString()).replace(nbsp, space); + } + + /** + * Escape the given {@link String} so it can be used in XML, as content. * - * @return the Base64 representation + * @param input + * the input {@link String} * - * @throws IOException - * in case of IO error + * @return the escaped {@link String} */ - static public String fromImage(BufferedImage image) throws IOException { - String imageString = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); + public static String xmlEscape(String input) { + if (input == null) { + return ""; + } - ImageIO.write(image, "jpeg", out); - byte[] imageBytes = out.toByteArray(); + return HtmlEscape.escapeHtml(input, + HtmlEscapeType.HTML4_NAMED_REFERENCES_DEFAULT_TO_HEXA, + HtmlEscapeLevel.LEVEL_1_ONLY_MARKUP_SIGNIFICANT); + } - imageString = new String(Base64.encodeBytes(imageBytes)); + /** + * Escape the given {@link String} so it can be used in XML, as text content + * inside double-quotes. + * + * @param input + * the input {@link String} + * + * @return the escaped {@link String} + */ + public static String xmlEscapeQuote(String input) { + if (input == null) { + return ""; + } - out.close(); + return HtmlEscape.escapeHtml(input, + HtmlEscapeType.HTML4_NAMED_REFERENCES_DEFAULT_TO_HEXA, + HtmlEscapeLevel.LEVEL_1_ONLY_MARKUP_SIGNIFICANT); + } - return imageString; + /** + * 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 + */ + @Deprecated + public static String zip64(String data) { + try { + return Base64.encodeBytes(data.getBytes("UTF-8"), Base64.GZIP); + } catch (IOException e) { + e.printStackTrace(); + return null; + } + } + + /** + * Unconvert from Base64 then unzip the content. + * + * @deprecated use {@link StringUtils#unbase64s(String, boolean)} with the + * correct parameter instead + * + * @param data + * the data in Base64 format + * + * @return the raw data + * + * @throws IOException + * in case of I/O error + */ + @Deprecated + public static String unzip64(String data) throws IOException { + return new String(Base64.decode(data, Base64.GZIP), "UTF-8"); } /** - * Convert the given {@link File} image into a Base64 representation of the - * same {@link File}. + * Convert the given data to Base64 format. * - * @param file - * the {@link File} image to convert + * @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 * - * @return the Base64 representation + * @return the Base64 {@link String} representation of the data * * @throws IOException - * in case of IO error + * in case of I/O errors */ - static public String fromStream(InputStream in) throws IOException { - String fileString = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); + public static String base64(String data, boolean zip) throws IOException { + return base64(data.getBytes("UTF-8"), zip); + } - byte[] buf = new byte[8192]; + /** + * Convert the given data to Base64 format. + * + * @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 + * + * @return the Base64 {@link String} representation of the data + * + * @throws IOException + * in case of I/O errors + */ + public static String base64(byte[] data, boolean zip) throws IOException { + return Base64.encodeBytes(data, zip ? Base64.GZIP : Base64.NO_OPTIONS); + } - int c = 0; - while ((c = in.read(buf, 0, buf.length)) > 0) { - out.write(buf, 0, c); + /** + * Convert the given data to Base64 format. + * + * @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); } - out.flush(); - in.close(); - fileString = new String(Base64.encodeBytes(out.toByteArray())); - out.close(); + return out; + } - return fileString; + /** + * Convert the given data to Base64 format. + * + * @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); + } + + return new Base64.InputStream(data, breakLines ? Base64.DO_BREAK_LINES + & Base64.ENCODE : Base64.ENCODE); } /** - * Convert the given Base64 representation of an image into an {@link Image} - * object. + * 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. * - * @param b64data - * the {@link Image} in Base64 format + * @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 {@link Image} object + * @return the raw data represented by the given Base64 {@link String}, + * optionally compressed with GZIP * * @throws IOException - * in case of IO error + * in case of I/O errors */ - static public BufferedImage toImage(String b64data) throws IOException { - ByteArrayInputStream in = new ByteArrayInputStream( - Base64.decode(b64data)); - return toImage(in); + public static byte[] unbase64(String data, boolean zip) throws IOException { + return Base64 + .decode(data, zip ? Base64.NO_OPTIONS : Base64.DONT_GUNZIP); } /** - * Convert the given {@link InputStream} (which must allow calls to - * {@link InputStream#reset()}) into an {@link Image} object. + * Unconvert the given data from Base64 format back to a raw array of bytes. * - * @param in - * the 'resetable' {@link InputStream} + * @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 Image} object + * @return the raw data represented by the given Base64 {@link String} * * @throws IOException - * in case of IO error + * in case of I/O errors */ - static public BufferedImage toImage(InputStream in) throws IOException { - int orientation; - try { - orientation = getExifTransorm(in); - } catch (Exception e) { - // no EXIF transform, ok - orientation = -1; + public static OutputStream unbase64(OutputStream data, boolean zip) + throws IOException { + OutputStream out = new Base64.OutputStream(data, Base64.DECODE); + + if (zip) { + out = new java.util.zip.GZIPOutputStream(out); } - in.reset(); - BufferedImage image = ImageIO.read(in); + return out; + } - if (image == null) { - throw new IOException("Failed to convert input to image"); + /** + * Unconvert the given data from Base64 format back to a raw array of bytes. + * + * @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} + * + * @throws IOException + * in case of I/O errors + */ + public static InputStream unbase64(InputStream data, boolean zip) + throws IOException { + if (zip) { + data = new java.util.zip.GZIPInputStream(data); } - // 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: - 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; - } + return new Base64.InputStream(data, Base64.DECODE); + } - if (affineTransform != null) { - AffineTransformOp affineTransformOp = new AffineTransformOp( - affineTransform, AffineTransformOp.TYPE_BILINEAR); + /** + * 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. + * + * @param data + * the data to unconvert + * @param offset + * the offset at which to start taking the data (do not take the + * data before it into account) + * @param count + * the number of bytes to take into account (do not process after + * this number of bytes has been processed) + * @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} + * + * @throws IOException + * in case of I/O errors + */ + public static byte[] unbase64(byte[] data, int offset, int count, + boolean zip) throws IOException { + return Base64.niki_decode(data, offset, count, zip ? Base64.NO_OPTIONS + : Base64.DONT_GUNZIP); + } - BufferedImage transformedImage = new BufferedImage(height, width, - image.getType()); - transformedImage = affineTransformOp - .filter(image, transformedImage); + /** + * Unonvert the given data from Base64 format back to a {@link String}. + *
+ * Will automatically detect zipped data and also uncompress it before + * returning, unless ZIP is false. + * + * @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 {@link String} represented by the given Base64 {@link String} + * , optionally compressed with GZIP + * + * @throws IOException + * in case of I/O errors + */ + public static String unbase64s(String data, boolean zip) throws IOException { + return new String(unbase64(data, zip), "UTF-8"); + } - image = transformedImage; - } - // + /** + * Unconvert the given data from Base64 format back into a {@link String}. + * + * @param data + * the data to unconvert + * @param offset + * the offset at which to start taking the data (do not take the + * data before it into account) + * @param count + * the number of bytes to take into account (do not process after + * this number of bytes has been processed) + * @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 + */ + public static String unbase64s(byte[] data, int offset, int count, + boolean zip) throws IOException { + return new String(unbase64(data, offset, count, zip), "UTF-8"); + } - return image; + /** + * 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: + *
+ * Examples (assuming decimalPositions = 1): + *
- * Note: this code has been found on internet; thank you anonymous coder. - *
+ * Of course, the conversion to and from display form is lossy (example: + * 6870 to "6.5k" to 6500). * - * @param in - * the data {@link InputStream} + * @param value + * the value in display form with possible "M" and "k" suffixes, + * can be NULL * - * @return the transformation flag if any + * @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 IO 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;
- }
+ * @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 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;
+ }
- /* 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 (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];
+ 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) {
}
- if (tagnum == 0x0112)
- break; /* found Orientation Tag */
- if (--number_of_tags == 0)
- return -1;
- offset += 12;
}
- /* 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];
- }
- if (set_flag > 8)
- return -1;
+ return count;
+ }
- return set_flag;
+ /**
+ * The "remove accents" pattern.
+ *
+ * @return the pattern, or NULL if a problem happens
+ */
+ private static Pattern getMarks() {
+ try {
+ return Pattern
+ .compile("[\\p{InCombiningDiacriticalMarks}\\p{IsLm}\\p{IsSk}]+");
+ } catch (Exception e) {
+ // Can fail on Android...
+ return null;
+ }
}
+ //
+ // justify List
+ * Note that we consider an empty line as full, and a line ending with
+ * spaces as not complete.
*
- * @param html
- * the HTML-encoded content
+ * @param line
+ * the line to check
*
- * @return the HTML-free equivalent content
+ * @return TRUE if it does
*/
- public static String unhtml(String html) {
- StringBuilder builder = new StringBuilder();
+ static private boolean isFullLine(StringBuilder line) {
+ if (line.length() == 0) {
+ return true;
+ }
- int inTag = 0;
- for (char car : html.toCharArray()) {
- if (car == '<') {
- inTag++;
- } else if (car == '>') {
- inTag--;
- } else if (inTag <= 0) {
- builder.append(car);
- }
+ char lastCar = line.charAt(line.length() - 1);
+ switch (lastCar) {
+ case '.': // points
+ case '?':
+ case '!':
+
+ case '\'': // quotes
+ case 'â':
+ case 'â':
+
+ case '"': // double quotes
+ case 'â':
+ case 'â':
+ case '»':
+ case '«':
+ return true;
+ default:
+ return false;
}
+ }
- return HtmlEscape.unescapeHtml(builder.toString());
+ /**
+ * Check if this line represent an item in a list or description (i.e.,
+ * check that the first non-space char is "-").
+ *
+ * @param line
+ * the line to check
+ *
+ * @return TRUE if it is
+ */
+ static private boolean isItemLine(String line) {
+ String spacing = getItemSpacing(line);
+ return spacing != null && !spacing.isEmpty()
+ && line.charAt(spacing.length()) == '-';
}
/**
- * Escape the given {@link String} so it can be used in XML, as content.
+ * Return all the spaces that start this line (or Empty if none).
*
- * @param input
- * the input {@link String}
+ * @param line
+ * the line to get the starting spaces from
*
- * @return the escaped {@link String}
+ * @return the left spacing
*/
- public static String xmlEscape(String input) {
- if (input == null) {
- return "";
+ static private String getItemSpacing(String line) {
+ int i;
+ for (i = 0; i < line.length(); i++) {
+ if (line.charAt(i) != ' ') {
+ return line.substring(0, i);
+ }
}
- return HtmlEscape.escapeHtml(input,
- HtmlEscapeType.HTML4_NAMED_REFERENCES_DEFAULT_TO_HEXA,
- HtmlEscapeLevel.LEVEL_1_ONLY_MARKUP_SIGNIFICANT);
+ return "";
}
/**
- * Escape the given {@link String} so it can be used in XML, as text content
- * inside double-quotes.
+ * This line is an horizontal spacer line.
*
- * @param input
- * the input {@link String}
+ * @param line
+ * the line to test
*
- * @return the escaped {@link String}
+ * @return TRUE if it is
*/
- public static String xmlEscapeQuote(String input) {
- if (input == null) {
- return "";
+ static private boolean isHrLine(CharSequence line) {
+ int count = 0;
+ if (line != null) {
+ for (int i = 0; i < line.length(); i++) {
+ char car = line.charAt(i);
+ if (car == ' ' || car == '\t' || car == '*' || car == '-'
+ || car == '_' || car == '~' || car == '=' || car == '/'
+ || car == '\\') {
+ count++;
+ } else {
+ return false;
+ }
+ }
}
- return HtmlEscape.escapeHtml(input,
- HtmlEscapeType.HTML4_NAMED_REFERENCES_DEFAULT_TO_HEXA,
- HtmlEscapeLevel.LEVEL_1_ONLY_MARKUP_SIGNIFICANT);
+ return count > 2;
}
}