weblib: fixes
[fanfix.git] / src / be / nikiroo / utils / StringUtils.java
1 package be.nikiroo.utils;
2
3 import java.io.ByteArrayInputStream;
4 import java.io.ByteArrayOutputStream;
5 import java.io.IOException;
6 import java.io.InputStream;
7 import java.io.OutputStream;
8 import java.io.UnsupportedEncodingException;
9 import java.security.MessageDigest;
10 import java.security.NoSuchAlgorithmException;
11 import java.text.Normalizer;
12 import java.text.Normalizer.Form;
13 import java.text.ParseException;
14 import java.text.SimpleDateFormat;
15 import java.util.AbstractMap;
16 import java.util.ArrayList;
17 import java.util.Arrays;
18 import java.util.Date;
19 import java.util.List;
20 import java.util.Map.Entry;
21 import java.util.regex.Pattern;
22 import java.util.zip.GZIPInputStream;
23 import java.util.zip.GZIPOutputStream;
24
25 import org.unbescape.html.HtmlEscape;
26 import org.unbescape.html.HtmlEscapeLevel;
27 import org.unbescape.html.HtmlEscapeType;
28
29 import be.nikiroo.utils.streams.Base64InputStream;
30 import be.nikiroo.utils.streams.Base64OutputStream;
31
32 /**
33 * This class offer some utilities based around {@link String}s.
34 *
35 * @author niki
36 */
37 public class StringUtils {
38 /**
39 * This enum type will decide the alignment of a {@link String} when padding
40 * or justification is applied (if there is enough horizontal space for it
41 * to be aligned).
42 */
43 public enum Alignment {
44 /** Aligned at left. */
45 LEFT,
46 /** Centered. */
47 CENTER,
48 /** Aligned at right. */
49 RIGHT,
50 /** Full justified (to both left and right). */
51 JUSTIFY,
52
53 // Old Deprecated values:
54
55 /** DEPRECATED: please use LEFT. */
56 @Deprecated
57 Beginning,
58 /** DEPRECATED: please use CENTER. */
59 @Deprecated
60 Center,
61 /** DEPRECATED: please use RIGHT. */
62 @Deprecated
63 End;
64
65 /**
66 * Return the non-deprecated version of this enum if needed (or return
67 * self if not).
68 *
69 * @return the non-deprecated value
70 */
71 Alignment undeprecate() {
72 if (this == Beginning)
73 return LEFT;
74 if (this == Center)
75 return CENTER;
76 if (this == End)
77 return RIGHT;
78 return this;
79 }
80 }
81
82 static private Pattern marks = getMarks();
83
84 /**
85 * Fix the size of the given {@link String} either with space-padding or by
86 * shortening it.
87 *
88 * @param text
89 * the {@link String} to fix
90 * @param width
91 * the size of the resulting {@link String} or -1 for a noop
92 *
93 * @return the resulting {@link String} of size <i>size</i>
94 */
95 static public String padString(String text, int width) {
96 return padString(text, width, true, null);
97 }
98
99 /**
100 * Fix the size of the given {@link String} either with space-padding or by
101 * optionally shortening it.
102 *
103 * @param text
104 * the {@link String} to fix
105 * @param width
106 * the size of the resulting {@link String} if the text fits or
107 * if cut is TRUE or -1 for a noop
108 * @param cut
109 * cut the {@link String} shorter if needed
110 * @param align
111 * align the {@link String} in this position if we have enough
112 * space (default is Alignment.Beginning)
113 *
114 * @return the resulting {@link String} of size <i>size</i> minimum
115 */
116 static public String padString(String text, int width, boolean cut,
117 Alignment align) {
118
119 if (align == null) {
120 align = Alignment.LEFT;
121 }
122
123 align = align.undeprecate();
124
125 if (width >= 0) {
126 if (text == null)
127 text = "";
128
129 int diff = width - text.length();
130
131 if (diff < 0) {
132 if (cut)
133 text = text.substring(0, width);
134 } else if (diff > 0) {
135 if (diff < 2 && align != Alignment.RIGHT)
136 align = Alignment.LEFT;
137
138 switch (align) {
139 case RIGHT:
140 text = new String(new char[diff]).replace('\0', ' ') + text;
141 break;
142 case CENTER:
143 int pad1 = (diff) / 2;
144 int pad2 = (diff + 1) / 2;
145 text = new String(new char[pad1]).replace('\0', ' ') + text
146 + new String(new char[pad2]).replace('\0', ' ');
147 break;
148 case LEFT:
149 default:
150 text = text + new String(new char[diff]).replace('\0', ' ');
151 break;
152 }
153 }
154 }
155
156 return text;
157 }
158
159 /**
160 * Justify a text into width-sized (at the maximum) lines and return all the
161 * lines concatenated into a single '\\n'-separated line of text.
162 *
163 * @param text
164 * the {@link String} to justify
165 * @param width
166 * the maximum size of the resulting lines
167 *
168 * @return a list of justified text lines concatenated into a single
169 * '\\n'-separated line of text
170 */
171 static public String justifyTexts(String text, int width) {
172 StringBuilder builder = new StringBuilder();
173 for (String line : justifyText(text, width, null)) {
174 if (builder.length() > 0) {
175 builder.append('\n');
176 }
177 builder.append(line);
178 }
179
180 return builder.toString();
181 }
182
183 /**
184 * Justify a text into width-sized (at the maximum) lines.
185 *
186 * @param text
187 * the {@link String} to justify
188 * @param width
189 * the maximum size of the resulting lines
190 *
191 * @return a list of justified text lines
192 */
193 static public List<String> justifyText(String text, int width) {
194 return justifyText(text, width, null);
195 }
196
197 /**
198 * Justify a text into width-sized (at the maximum) lines.
199 *
200 * @param text
201 * the {@link String} to justify
202 * @param width
203 * the maximum size of the resulting lines
204 * @param align
205 * align the lines in this position (default is
206 * Alignment.Beginning)
207 *
208 * @return a list of justified text lines
209 */
210 static public List<String> justifyText(String text, int width,
211 Alignment align) {
212 if (align == null) {
213 align = Alignment.LEFT;
214 }
215
216 align = align.undeprecate();
217
218 switch (align) {
219 case CENTER:
220 return StringJustifier.center(text, width);
221 case RIGHT:
222 return StringJustifier.right(text, width);
223 case JUSTIFY:
224 return StringJustifier.full(text, width);
225 case LEFT:
226 default:
227 return StringJustifier.left(text, width);
228 }
229 }
230
231 /**
232 * Justify a text into width-sized (at the maximum) lines.
233 *
234 * @param text
235 * the {@link String} to justify
236 * @param width
237 * the maximum size of the resulting lines
238 *
239 * @return a list of justified text lines
240 */
241 static public List<String> justifyText(List<String> text, int width) {
242 return justifyText(text, width, null);
243 }
244
245 /**
246 * Justify a text into width-sized (at the maximum) lines.
247 *
248 * @param text
249 * the {@link String} to justify
250 * @param width
251 * the maximum size of the resulting lines
252 * @param align
253 * align the lines in this position (default is
254 * Alignment.Beginning)
255 *
256 * @return a list of justified text lines
257 */
258 static public List<String> justifyText(List<String> text, int width,
259 Alignment align) {
260 List<String> result = new ArrayList<String>();
261
262 // Content <-> Bullet spacing (null = no spacing)
263 List<Entry<String, String>> lines = new ArrayList<Entry<String, String>>();
264 StringBuilder previous = null;
265 StringBuilder tmp = new StringBuilder();
266 String previousItemBulletSpacing = null;
267 String itemBulletSpacing = null;
268 for (String inputLine : text) {
269 boolean previousLineComplete = true;
270
271 String current = inputLine.replace("\t", " ");
272 itemBulletSpacing = getItemSpacing(current);
273 boolean bullet = isItemLine(current);
274 if ((previousItemBulletSpacing == null || itemBulletSpacing
275 .length() <= previousItemBulletSpacing.length()) && !bullet) {
276 itemBulletSpacing = null;
277 }
278
279 if (itemBulletSpacing != null) {
280 current = current.trim();
281 if (!current.isEmpty() && bullet) {
282 current = current.substring(1);
283 }
284 current = current.trim();
285 previousLineComplete = bullet;
286 } else {
287 tmp.setLength(0);
288 for (String word : current.split(" ")) {
289 if (word.isEmpty()) {
290 continue;
291 }
292
293 if (tmp.length() > 0) {
294 tmp.append(' ');
295 }
296 tmp.append(word.trim());
297 }
298 current = tmp.toString();
299
300 previousLineComplete = current.isEmpty()
301 || previousItemBulletSpacing != null
302 || (previous != null && isFullLine(previous))
303 || isHrLine(current) || isHrLine(previous);
304 }
305
306 if (previous == null) {
307 previous = new StringBuilder();
308 } else {
309 if (previousLineComplete) {
310 lines.add(new AbstractMap.SimpleEntry<String, String>(
311 previous.toString(), previousItemBulletSpacing));
312 previous.setLength(0);
313 previousItemBulletSpacing = itemBulletSpacing;
314 } else {
315 previous.append(' ');
316 }
317 }
318
319 previous.append(current);
320
321 }
322
323 if (previous != null) {
324 lines.add(new AbstractMap.SimpleEntry<String, String>(previous
325 .toString(), previousItemBulletSpacing));
326 }
327
328 for (Entry<String, String> line : lines) {
329 String content = line.getKey();
330 String spacing = line.getValue();
331
332 String bullet = "- ";
333 if (spacing == null) {
334 bullet = "";
335 spacing = "";
336 }
337
338 if (spacing.length() > width + 3) {
339 spacing = "";
340 }
341
342 for (String subline : StringUtils.justifyText(content, width
343 - (spacing.length() + bullet.length()), align)) {
344 result.add(spacing + bullet + subline);
345 if (!bullet.isEmpty()) {
346 bullet = " ";
347 }
348 }
349 }
350
351 return result;
352 }
353
354 /**
355 * Sanitise the given input to make it more Terminal-friendly by removing
356 * combining characters.
357 *
358 * @param input
359 * the input to sanitise
360 * @param allowUnicode
361 * allow Unicode or only allow ASCII Latin characters
362 *
363 * @return the sanitised {@link String}
364 */
365 static public String sanitize(String input, boolean allowUnicode) {
366 return sanitize(input, allowUnicode, !allowUnicode);
367 }
368
369 /**
370 * Sanitise the given input to make it more Terminal-friendly by removing
371 * combining characters.
372 *
373 * @param input
374 * the input to sanitise
375 * @param allowUnicode
376 * allow Unicode or only allow ASCII Latin characters
377 * @param removeAllAccents
378 * TRUE to replace all accentuated characters by their non
379 * accentuated counter-parts
380 *
381 * @return the sanitised {@link String}
382 */
383 static public String sanitize(String input, boolean allowUnicode,
384 boolean removeAllAccents) {
385
386 if (removeAllAccents) {
387 input = Normalizer.normalize(input, Form.NFKD);
388 if (marks != null) {
389 input = marks.matcher(input).replaceAll("");
390 }
391 }
392
393 input = Normalizer.normalize(input, Form.NFKC);
394
395 if (!allowUnicode) {
396 StringBuilder builder = new StringBuilder();
397 for (int index = 0; index < input.length(); index++) {
398 char car = input.charAt(index);
399 // displayable chars in ASCII are in the range 32<->255,
400 // except DEL (127)
401 if (car >= 32 && car <= 255 && car != 127) {
402 builder.append(car);
403 }
404 }
405 input = builder.toString();
406 }
407
408 return input;
409 }
410
411 /**
412 * Convert between the time in milliseconds to a {@link String} in a "fixed"
413 * way (to exchange data over the wire, for instance).
414 * <p>
415 * Precise to the second.
416 *
417 * @param time
418 * the specified number of milliseconds since the standard base
419 * time known as "the epoch", namely January 1, 1970, 00:00:00
420 * GMT
421 *
422 * @return the time as a {@link String}
423 */
424 static public String fromTime(long time) {
425 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
426 return sdf.format(new Date(time));
427 }
428
429 /**
430 * Convert between the time as a {@link String} to milliseconds in a "fixed"
431 * way (to exchange data over the wire, for instance).
432 * <p>
433 * Precise to the second.
434 *
435 * @param displayTime
436 * the time as a {@link String}
437 *
438 * @return the number of milliseconds since the standard base time known as
439 * "the epoch", namely January 1, 1970, 00:00:00 GMT, or -1 in case
440 * of error
441 *
442 * @throws ParseException
443 * in case of parse error
444 */
445 static public long toTime(String displayTime) throws ParseException {
446 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
447 return sdf.parse(displayTime).getTime();
448 }
449
450 /**
451 * Return a hash of the given {@link String}.
452 *
453 * @param input
454 * the input data
455 *
456 * @return the hash
457 *
458 * @deprecated please use {@link HashUtils}
459 */
460 @Deprecated
461 static public String getMd5Hash(String input) {
462 try {
463 MessageDigest md = MessageDigest.getInstance("MD5");
464 md.update(getBytes(input));
465 byte byteData[] = md.digest();
466
467 StringBuffer hexString = new StringBuffer();
468 for (int i = 0; i < byteData.length; i++) {
469 String hex = Integer.toHexString(0xff & byteData[i]);
470 if (hex.length() == 1)
471 hexString.append('0');
472 hexString.append(hex);
473 }
474
475 return hexString.toString();
476 } catch (NoSuchAlgorithmException e) {
477 return input;
478 }
479 }
480
481 /**
482 * Remove the HTML content from the given input, and un-html-ize the rest.
483 *
484 * @param html
485 * the HTML-encoded content
486 *
487 * @return the HTML-free equivalent content
488 */
489 public static String unhtml(String html) {
490 StringBuilder builder = new StringBuilder();
491
492 int inTag = 0;
493 for (char car : html.toCharArray()) {
494 if (car == '<') {
495 inTag++;
496 } else if (car == '>') {
497 inTag--;
498 } else if (inTag <= 0) {
499 builder.append(car);
500 }
501 }
502
503 char nbsp = ' '; // non-breakable space (a special char)
504 char space = ' ';
505 return HtmlEscape.unescapeHtml(builder.toString()).replace(nbsp, space);
506 }
507
508 /**
509 * Escape the given {@link String} so it can be used in XML, as content.
510 *
511 * @param input
512 * the input {@link String}
513 *
514 * @return the escaped {@link String}
515 */
516 public static String xmlEscape(String input) {
517 if (input == null) {
518 return "";
519 }
520
521 return HtmlEscape.escapeHtml(input,
522 HtmlEscapeType.HTML4_NAMED_REFERENCES_DEFAULT_TO_HEXA,
523 HtmlEscapeLevel.LEVEL_1_ONLY_MARKUP_SIGNIFICANT);
524 }
525
526 /**
527 * Escape the given {@link String} so it can be used in XML, as text content
528 * inside double-quotes.
529 *
530 * @param input
531 * the input {@link String}
532 *
533 * @return the escaped {@link String}
534 */
535 public static String xmlEscapeQuote(String input) {
536 if (input == null) {
537 return "";
538 }
539
540 return HtmlEscape.escapeHtml(input,
541 HtmlEscapeType.HTML4_NAMED_REFERENCES_DEFAULT_TO_HEXA,
542 HtmlEscapeLevel.LEVEL_1_ONLY_MARKUP_SIGNIFICANT);
543 }
544
545 /**
546 * Zip the data and then encode it into Base64.
547 *
548 * @param data
549 * the data
550 *
551 * @return the Base64 zipped version
552 *
553 * @throws IOException
554 * in case of I/O error
555 */
556 public static String zip64(String data) throws IOException {
557 try {
558 return zip64(getBytes(data));
559 } catch (UnsupportedEncodingException e) {
560 // All conforming JVM are required to support UTF-8
561 e.printStackTrace();
562 return null;
563 }
564 }
565
566 /**
567 * Zip the data and then encode it into Base64.
568 *
569 * @param data
570 * the data
571 *
572 * @return the Base64 zipped version
573 *
574 * @throws IOException
575 * in case of I/O error
576 */
577 public static String zip64(byte[] data) throws IOException {
578 // 1. compress
579 ByteArrayOutputStream bout = new ByteArrayOutputStream();
580 try {
581 OutputStream out = new GZIPOutputStream(bout);
582 try {
583 out.write(data);
584 } finally {
585 out.close();
586 }
587 } finally {
588 data = bout.toByteArray();
589 bout.close();
590 }
591
592 // 2. base64
593 InputStream in = new ByteArrayInputStream(data);
594 try {
595 in = new Base64InputStream(in, true);
596 return new String(IOUtils.toByteArray(in), "UTF-8");
597 } finally {
598 in.close();
599 }
600 }
601
602 /**
603 * Unconvert from Base64 then unzip the content, which is assumed to be a
604 * String.
605 *
606 * @param data
607 * the data in Base64 format
608 *
609 * @return the raw data
610 *
611 * @throws IOException
612 * in case of I/O error
613 */
614 public static String unzip64s(String data) throws IOException {
615 return new String(unzip64(data), "UTF-8");
616 }
617
618 /**
619 * Unconvert from Base64 then unzip the content.
620 *
621 * @param data
622 * the data in Base64 format
623 *
624 * @return the raw data
625 *
626 * @throws IOException
627 * in case of I/O error
628 */
629 public static byte[] unzip64(String data) throws IOException {
630 InputStream in = new Base64InputStream(new ByteArrayInputStream(
631 getBytes(data)), false);
632 try {
633 in = new GZIPInputStream(in);
634 return IOUtils.toByteArray(in);
635 } finally {
636 in.close();
637 }
638 }
639
640 /**
641 * Convert the given data to Base64 format.
642 *
643 * @param data
644 * the data to convert
645 *
646 * @return the Base64 {@link String} representation of the data
647 *
648 * @throws IOException
649 * in case of I/O errors
650 */
651 public static String base64(String data) throws IOException {
652 return base64(getBytes(data));
653 }
654
655 /**
656 * Convert the given data to Base64 format.
657 *
658 * @param data
659 * the data to convert
660 *
661 * @return the Base64 {@link String} representation of the data
662 *
663 * @throws IOException
664 * in case of I/O errors
665 */
666 public static String base64(byte[] data) throws IOException {
667 Base64InputStream in = new Base64InputStream(new ByteArrayInputStream(
668 data), true);
669 try {
670 return new String(IOUtils.toByteArray(in), "UTF-8");
671 } finally {
672 in.close();
673 }
674 }
675
676 /**
677 * Unconvert the given data from Base64 format back to a raw array of bytes.
678 *
679 * @param data
680 * the data to unconvert
681 *
682 * @return the raw data represented by the given Base64 {@link String},
683 *
684 * @throws IOException
685 * in case of I/O errors
686 */
687 public static byte[] unbase64(String data) throws IOException {
688 Base64InputStream in = new Base64InputStream(new ByteArrayInputStream(
689 getBytes(data)), false);
690 try {
691 return IOUtils.toByteArray(in);
692 } finally {
693 in.close();
694 }
695 }
696
697 /**
698 * Unonvert the given data from Base64 format back to a {@link String}.
699 *
700 * @param data
701 * the data to unconvert
702 *
703 * @return the {@link String} represented by the given Base64 {@link String}
704 *
705 * @throws IOException
706 * in case of I/O errors
707 */
708 public static String unbase64s(String data) throws IOException {
709 return new String(unbase64(data), "UTF-8");
710 }
711
712 /**
713 * Return a display {@link String} for the given value, which can be
714 * suffixed with "k" or "M" depending upon the number, if it is big enough.
715 * <p>
716 * <p>
717 * Examples:
718 * <ul>
719 * <li><tt>8 765</tt> becomes "8 k"</li>
720 * <li><tt>998 765</tt> becomes "998 k"</li>
721 * <li><tt>12 987 364</tt> becomes "12 M"</li>
722 * <li><tt>5 534 333 221</tt> becomes "5 G"</li>
723 * </ul>
724 *
725 * @param value
726 * the value to convert
727 *
728 * @return the display value
729 */
730 public static String formatNumber(long value) {
731 return formatNumber(value, 0);
732 }
733
734 /**
735 * Return a display {@link String} for the given value, which can be
736 * suffixed with "k" or "M" depending upon the number, if it is big enough.
737 * <p>
738 * Examples (assuming decimalPositions = 1):
739 * <ul>
740 * <li><tt>8 765</tt> becomes "8.7 k"</li>
741 * <li><tt>998 765</tt> becomes "998.7 k"</li>
742 * <li><tt>12 987 364</tt> becomes "12.9 M"</li>
743 * <li><tt>5 534 333 221</tt> becomes "5.5 G"</li>
744 * </ul>
745 *
746 * @param value
747 * the value to convert
748 * @param decimalPositions
749 * the number of decimal positions to keep
750 *
751 * @return the display value
752 */
753 public static String formatNumber(long value, int decimalPositions) {
754 long userValue = value;
755 String suffix = " ";
756 long mult = 1;
757
758 if (value >= 1000000000l) {
759 mult = 1000000000l;
760 userValue = value / 1000000000l;
761 suffix = " G";
762 } else if (value >= 1000000l) {
763 mult = 1000000l;
764 userValue = value / 1000000l;
765 suffix = " M";
766 } else if (value >= 1000l) {
767 mult = 1000l;
768 userValue = value / 1000l;
769 suffix = " k";
770 }
771
772 String deci = "";
773 if (decimalPositions > 0) {
774 deci = Long.toString(value % mult);
775 int size = Long.toString(mult).length() - 1;
776 while (deci.length() < size) {
777 deci = "0" + deci;
778 }
779
780 deci = deci.substring(0, Math.min(decimalPositions, deci.length()));
781 while (deci.length() < decimalPositions) {
782 deci += "0";
783 }
784
785 deci = "." + deci;
786 }
787
788 return Long.toString(userValue) + deci + suffix;
789 }
790
791 /**
792 * The reverse operation to {@link StringUtils#formatNumber(long)}: it will
793 * read a "display" number that can contain a "M" or "k" suffix and return
794 * the full value.
795 * <p>
796 * Of course, the conversion to and from display form is lossy (example:
797 * <tt>6870</tt> to "6.5k" to <tt>6500</tt>).
798 *
799 * @param value
800 * the value in display form with possible "M" and "k" suffixes,
801 * can be NULL
802 *
803 * @return the value as a number, or 0 if not possible to convert
804 */
805 public static long toNumber(String value) {
806 return toNumber(value, 0l);
807 }
808
809 /**
810 * The reverse operation to {@link StringUtils#formatNumber(long)}: it will
811 * read a "display" number that can contain a "M" or "k" suffix and return
812 * the full value.
813 * <p>
814 * Of course, the conversion to and from display form is lossy (example:
815 * <tt>6870</tt> to "6.5k" to <tt>6500</tt>).
816 *
817 * @param value
818 * the value in display form with possible "M" and "k" suffixes,
819 * can be NULL
820 * @param def
821 * the default value if it is not possible to convert the given
822 * value to a number
823 *
824 * @return the value as a number, or 0 if not possible to convert
825 */
826 public static long toNumber(String value, long def) {
827 long count = def;
828 if (value != null) {
829 value = value.trim().toLowerCase();
830 try {
831 long mult = 1;
832 if (value.endsWith("g")) {
833 value = value.substring(0, value.length() - 1).trim();
834 mult = 1000000000;
835 } else if (value.endsWith("m")) {
836 value = value.substring(0, value.length() - 1).trim();
837 mult = 1000000;
838 } else if (value.endsWith("k")) {
839 value = value.substring(0, value.length() - 1).trim();
840 mult = 1000;
841 }
842
843 long deci = 0;
844 if (value.contains(".")) {
845 String[] tab = value.split("\\.");
846 if (tab.length != 2) {
847 throw new NumberFormatException(value);
848 }
849 double decimal = Double.parseDouble("0."
850 + tab[tab.length - 1]);
851 deci = ((long) (mult * decimal));
852 value = tab[0];
853 }
854 count = mult * Long.parseLong(value) + deci;
855 } catch (Exception e) {
856 }
857 }
858
859 return count;
860 }
861
862 /**
863 * Return the bytes array representation of the given {@link String} in
864 * UTF-8.
865 *
866 * @param str
867 * the {@link String} to transform into bytes
868 * @return the content in bytes
869 */
870 static public byte[] getBytes(String str) {
871 try {
872 return str.getBytes("UTF-8");
873 } catch (UnsupportedEncodingException e) {
874 // All conforming JVM must support UTF-8
875 e.printStackTrace();
876 return null;
877 }
878 }
879
880 /**
881 * The "remove accents" pattern.
882 *
883 * @return the pattern, or NULL if a problem happens
884 */
885 private static Pattern getMarks() {
886 try {
887 return Pattern
888 .compile("[\\p{InCombiningDiacriticalMarks}\\p{IsLm}\\p{IsSk}]+");
889 } catch (Exception e) {
890 // Can fail on Android...
891 return null;
892 }
893 }
894
895 //
896 // justify List<String> related:
897 //
898
899 /**
900 * Check if this line ends as a complete line (ends with a "." or similar).
901 * <p>
902 * Note that we consider an empty line as full, and a line ending with
903 * spaces as not complete.
904 *
905 * @param line
906 * the line to check
907 *
908 * @return TRUE if it does
909 */
910 static private boolean isFullLine(StringBuilder line) {
911 if (line.length() == 0) {
912 return true;
913 }
914
915 char lastCar = line.charAt(line.length() - 1);
916 switch (lastCar) {
917 case '.': // points
918 case '?':
919 case '!':
920
921 case '\'': // quotes
922 case '‘':
923 case '’':
924
925 case '"': // double quotes
926 case '”':
927 case '“':
928 case '»':
929 case '«':
930 return true;
931 default:
932 return false;
933 }
934 }
935
936 /**
937 * Check if this line represent an item in a list or description (i.e.,
938 * check that the first non-space char is "-").
939 *
940 * @param line
941 * the line to check
942 *
943 * @return TRUE if it is
944 */
945 static private boolean isItemLine(String line) {
946 String spacing = getItemSpacing(line);
947 return spacing != null && !spacing.isEmpty()
948 && line.charAt(spacing.length()) == '-';
949 }
950
951 /**
952 * Return all the spaces that start this line (or Empty if none).
953 *
954 * @param line
955 * the line to get the starting spaces from
956 *
957 * @return the left spacing
958 */
959 static private String getItemSpacing(String line) {
960 int i;
961 for (i = 0; i < line.length(); i++) {
962 if (line.charAt(i) != ' ') {
963 return line.substring(0, i);
964 }
965 }
966
967 return "";
968 }
969
970 /**
971 * This line is an horizontal spacer line.
972 *
973 * @param line
974 * the line to test
975 *
976 * @return TRUE if it is
977 */
978 static private boolean isHrLine(CharSequence line) {
979 int count = 0;
980 if (line != null) {
981 for (int i = 0; i < line.length(); i++) {
982 char car = line.charAt(i);
983 if (car == ' ' || car == '\t' || car == '*' || car == '-'
984 || car == '_' || car == '~' || car == '=' || car == '/'
985 || car == '\\') {
986 count++;
987 } else {
988 return false;
989 }
990 }
991 }
992
993 return count > 2;
994 }
995
996 // Deprecated functions, please do not use //
997
998 /**
999 * @deprecated please use {@link StringUtils#zip64(byte[])} or
1000 * {@link StringUtils#base64(byte[])} instead.
1001 *
1002 * @param data
1003 * the data to encode
1004 * @param zip
1005 * TRUE to zip it before Base64 encoding it, FALSE for Base64
1006 * encoding only
1007 *
1008 * @return the encoded data
1009 *
1010 * @throws IOException
1011 * in case of I/O error
1012 */
1013 @Deprecated
1014 public static String base64(String data, boolean zip) throws IOException {
1015 return base64(getBytes(data), zip);
1016 }
1017
1018 /**
1019 * @deprecated please use {@link StringUtils#zip64(String)} or
1020 * {@link StringUtils#base64(String)} instead.
1021 *
1022 * @param data
1023 * the data to encode
1024 * @param zip
1025 * TRUE to zip it before Base64 encoding it, FALSE for Base64
1026 * encoding only
1027 *
1028 * @return the encoded data
1029 *
1030 * @throws IOException
1031 * in case of I/O error
1032 */
1033 @Deprecated
1034 public static String base64(byte[] data, boolean zip) throws IOException {
1035 if (zip) {
1036 return zip64(data);
1037 }
1038
1039 Base64InputStream b64 = new Base64InputStream(new ByteArrayInputStream(
1040 data), true);
1041 try {
1042 return IOUtils.readSmallStream(b64);
1043 } finally {
1044 b64.close();
1045 }
1046 }
1047
1048 /**
1049 * @deprecated please use {@link Base64OutputStream} and
1050 * {@link GZIPOutputStream} instead.
1051 *
1052 * @param breakLines
1053 * NOT USED ANYMORE, it is always considered FALSE now
1054 */
1055 @Deprecated
1056 public static OutputStream base64(OutputStream data, boolean zip,
1057 boolean breakLines) throws IOException {
1058 OutputStream out = new Base64OutputStream(data);
1059 if (zip) {
1060 out = new java.util.zip.GZIPOutputStream(out);
1061 }
1062
1063 return out;
1064 }
1065
1066 /**
1067 * Unconvert the given data from Base64 format back to a raw array of bytes.
1068 * <p>
1069 * Will automatically detect zipped data and also uncompress it before
1070 * returning, unless ZIP is false.
1071 *
1072 * @deprecated DO NOT USE ANYMORE (bad perf, will be dropped)
1073 *
1074 * @param data
1075 * the data to unconvert
1076 * @param zip
1077 * TRUE to also uncompress the data from a GZIP format
1078 * automatically; if set to FALSE, zipped data can be returned
1079 *
1080 * @return the raw data represented by the given Base64 {@link String},
1081 * optionally compressed with GZIP
1082 *
1083 * @throws IOException
1084 * in case of I/O errors
1085 */
1086 @Deprecated
1087 public static byte[] unbase64(String data, boolean zip) throws IOException {
1088 byte[] buffer = unbase64(data);
1089 if (!zip) {
1090 return buffer;
1091 }
1092
1093 try {
1094 GZIPInputStream zipped = new GZIPInputStream(
1095 new ByteArrayInputStream(buffer));
1096 try {
1097 ByteArrayOutputStream out = new ByteArrayOutputStream();
1098 try {
1099 IOUtils.write(zipped, out);
1100 return out.toByteArray();
1101 } finally {
1102 out.close();
1103 }
1104 } finally {
1105 zipped.close();
1106 }
1107 } catch (Exception e) {
1108 return buffer;
1109 }
1110 }
1111
1112 /**
1113 * Unconvert the given data from Base64 format back to a raw array of bytes.
1114 * <p>
1115 * Will automatically detect zipped data and also uncompress it before
1116 * returning, unless ZIP is false.
1117 *
1118 * @deprecated DO NOT USE ANYMORE (bad perf, will be dropped)
1119 *
1120 * @param data
1121 * the data to unconvert
1122 * @param zip
1123 * TRUE to also uncompress the data from a GZIP format
1124 * automatically; if set to FALSE, zipped data can be returned
1125 *
1126 * @return the raw data represented by the given Base64 {@link String},
1127 * optionally compressed with GZIP
1128 *
1129 * @throws IOException
1130 * in case of I/O errors
1131 */
1132 @Deprecated
1133 public static InputStream unbase64(InputStream data, boolean zip)
1134 throws IOException {
1135 return new ByteArrayInputStream(unbase64(IOUtils.readSmallStream(data),
1136 zip));
1137 }
1138
1139 /**
1140 * @deprecated DO NOT USE ANYMORE (bad perf, will be dropped)
1141 */
1142 @Deprecated
1143 public static byte[] unbase64(byte[] data, int offset, int count,
1144 boolean zip) throws IOException {
1145 byte[] dataPart = Arrays.copyOfRange(data, offset, offset + count);
1146 return unbase64(new String(dataPart, "UTF-8"), zip);
1147 }
1148
1149 /**
1150 * @deprecated DO NOT USE ANYMORE (bad perf, will be dropped)
1151 */
1152 @Deprecated
1153 public static String unbase64s(String data, boolean zip) throws IOException {
1154 return new String(unbase64(data, zip), "UTF-8");
1155 }
1156
1157 /**
1158 * @deprecated DO NOT USE ANYMORE (bad perf, will be dropped)
1159 */
1160 @Deprecated
1161 public static String unbase64s(byte[] data, int offset, int count,
1162 boolean zip) throws IOException {
1163 return new String(unbase64(data, offset, count, zip), "UTF-8");
1164 }
1165 }