+ * 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} */ @@ -186,96 +395,24 @@ 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 displayTime * the time as a {@link String} * - * @return the time in milliseconds - */ - static public long toTime(String displayTime) { - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); - try { - return sdf.parse(displayTime).getTime(); - } catch (ParseException e) { - return -1; - } - } - - /** - * Convert the given {@link Image} object into a Base64 representation of - * the same {@link Image}. object. - * - * @param image - * the {@link Image} object to convert + * @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 * - * @return the Base64 representation - * - * @throws IOException - * in case of IO error + * @throws ParseException + * in case of parse error */ - static public String fromImage(BufferedImage image) throws IOException { - String imageString = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - - ImageIO.write(image, "jpeg", out); - byte[] imageBytes = out.toByteArray(); - - imageString = new String(Base64.encodeBytes(imageBytes)); - - out.close(); - - return imageString; - } - - /** - * Convert the given image into a Base64 representation of the same - * {@link File}. - * - * @param in - * the image to convert - * - * @return the Base64 representation - * - * @throws IOException - * in case of IO error - */ - static public String fromStream(InputStream in) throws IOException { - String fileString = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - - byte[] buf = new byte[8192]; - - int c = 0; - while ((c = in.read(buf, 0, buf.length)) > 0) { - out.write(buf, 0, c); - } - out.flush(); - in.close(); - - fileString = new String(Base64.encodeBytes(out.toByteArray())); - out.close(); - - return fileString; - } - - /** - * Convert the given Base64 representation of an image into an {@link Image} - * object. - * - * @param b64data - * the {@link Image} in Base64 format - * - * @return the {@link Image} object - * - * @throws IOException - * in case of IO error - */ - static public BufferedImage toImage(String b64data) throws IOException { - ByteArrayInputStream in = new ByteArrayInputStream( - Base64.decode(b64data)); - return IOUtils.toImage(in); + static public long toTime(String displayTime) throws ParseException { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + return sdf.parse(displayTime).getTime(); } /** @@ -286,10 +423,10 @@ public class StringUtils { * * @return the hash */ - static public String getHash(String input) { + static public String getMd5Hash(String input) { try { MessageDigest md = MessageDigest.getInstance("MD5"); - md.update(input.getBytes()); + md.update(input.getBytes("UTF-8")); byte byteData[] = md.digest(); StringBuffer hexString = new StringBuffer(); @@ -303,6 +440,8 @@ public class StringUtils { return hexString.toString(); } catch (NoSuchAlgorithmException e) { return input; + } catch (UnsupportedEncodingException e) { + return input; } } @@ -370,25 +509,405 @@ public class StringUtils { HtmlEscapeLevel.LEVEL_1_ONLY_MARKUP_SIGNIFICANT); } + /** + * 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(), Base64.GZIP); + 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 { - ByteArrayInputStream in = new ByteArrayInputStream(Base64.decode(data, - Base64.GZIP)); + return new String(Base64.decode(data, Base64.GZIP), "UTF-8"); + } + + /** + * 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(String data, boolean zip) throws IOException { + return base64(data.getBytes("UTF-8"), zip); + } + + /** + * 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); + } + + /** + * 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); + } + + return out; + } + + /** + * 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); + } + + /** + * 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 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 + */ + public static byte[] unbase64(String data, boolean zip) throws IOException { + return Base64 + .decode(data, zip ? Base64.NO_OPTIONS : Base64.DONT_GUNZIP); + } + + /** + * 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 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); + } + + return out; + } + + /** + * 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); + } - Scanner scan = new Scanner(in); - scan.useDelimiter("\\A"); + return new Base64.InputStream(data, Base64.DECODE); + } + + /** + * 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); + } + + /** + * 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");
+ }
+
+ /**
+ * 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");
+ }
+
+ /**
+ * The "remove accents" pattern.
+ *
+ * @return the pattern, or NULL if a problem happens
+ */
+ private static Pattern getMarks() {
try {
- return scan.next();
- } finally {
- scan.close();
+ 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 line
+ * the line to check
+ *
+ * @return TRUE if it does
+ */
+ static private boolean isFullLine(StringBuilder line) {
+ if (line.length() == 0) {
+ return true;
+ }
+
+ 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;
+ }
+ }
+
+ /**
+ * 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()) == '-';
+ }
+
+ /**
+ * Return all the spaces that start this line (or Empty if none).
+ *
+ * @param line
+ * the line to get the starting spaces from
+ *
+ * @return the left spacing
+ */
+ 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 "";
+ }
+
+ /**
+ * This line is an horizontal spacer line.
+ *
+ * @param line
+ * the line to test
+ *
+ * @return TRUE if it is
+ */
+ 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 count > 2;
+ }
}