package be.nikiroo.utils;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.Normalizer;
import java.text.Normalizer.Form;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Pattern;
import javax.imageio.ImageIO;
import org.unbescape.html.HtmlEscape;
import org.unbescape.html.HtmlEscapeLevel;
import org.unbescape.html.HtmlEscapeType;
/**
* This class offer some utilities based around {@link String}s.
*
* @author niki
*/
public class StringUtils {
/**
* This enum type will decide the alignment of a {@link String} when padding
* is applied or if there is enough horizontal space for it to be aligned.
*/
public enum Alignment {
/** Aligned at left. */
Beginning,
/** Centered. */
Center,
/** Aligned at right. */
End
}
static private Pattern marks = Pattern
.compile("[\\p{InCombiningDiacriticalMarks}\\p{IsLm}\\p{IsSk}]+");
/**
* Fix the size of the given {@link String} either with space-padding or by
* shortening it.
*
* @param text
* the {@link String} to fix
* @param width
* the size of the resulting {@link String} or -1 for a noop
*
* @return the resulting {@link String} of size size
*/
static public String padString(String text, int width) {
return padString(text, width, true, Alignment.Beginning);
}
/**
* Fix the size of the given {@link String} either with space-padding or by
* optionally shortening it.
*
* @param text
* the {@link String} to fix
* @param width
* the size of the resulting {@link String} if the text fits or
* if cut is TRUE or -1 for a noop
* @param cut
* cut the {@link String} shorter if needed
* @param align
* align the {@link String} in this position if we have enough
* space
*
* @return the resulting {@link String} of size size minimum
*/
static public String padString(String text, int width, boolean cut,
Alignment align) {
if (width >= 0) {
if (text == null)
text = "";
int diff = width - text.length();
if (diff < 0) {
if (cut)
text = text.substring(0, width);
} else if (diff > 0) {
if (diff < 2 && align != Alignment.End)
align = Alignment.Beginning;
switch (align) {
case Beginning:
text = text + new String(new char[diff]).replace('\0', ' ');
break;
case End:
text = new String(new char[diff]).replace('\0', ' ') + text;
break;
case Center:
default:
int pad1 = (diff) / 2;
int pad2 = (diff + 1) / 2;
text = new String(new char[pad1]).replace('\0', ' ') + text
+ new String(new char[pad2]).replace('\0', ' ');
break;
}
}
}
return text;
}
/**
* Sanitise the given input to make it more Terminal-friendly by removing
* combining characters.
*
* @param input
* the input to sanitise
* @param allowUnicode
* allow Unicode or only allow ASCII Latin characters
*
* @return the sanitised {@link String}
*/
static public String sanitize(String input, boolean allowUnicode) {
return sanitize(input, allowUnicode, !allowUnicode);
}
/**
* Sanitise the given input to make it more Terminal-friendly by removing
* combining characters.
*
* @param input
* the input to sanitise
* @param allowUnicode
* allow Unicode or only allow ASCII Latin characters
* @param removeAllAccents
* TRUE to replace all accentuated characters by their non
* accentuated counter-parts
*
* @return the sanitised {@link String}
*/
static public String sanitize(String input, boolean allowUnicode,
boolean removeAllAccents) {
if (removeAllAccents) {
input = Normalizer.normalize(input, Form.NFKD);
input = marks.matcher(input).replaceAll("");
}
input = Normalizer.normalize(input, Form.NFKC);
if (!allowUnicode) {
StringBuilder builder = new StringBuilder();
for (int index = 0; index < input.length(); index++) {
char car = input.charAt(index);
// displayable chars in ASCII are in the range 32<->255,
// except DEL (127)
if (car >= 32 && car <= 255 && car != 127) {
builder.append(car);
}
}
input = builder.toString();
}
return input;
}
/**
* Convert between time in milliseconds to {@link String} in a "static" way
* (to exchange data over the wire, for instance).
*
* @param time
* the time in milliseconds
*
* @return the time as a {@link String}
*/
static public String fromTime(long time) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return sdf.format(new Date(time));
}
/**
* Convert between time as a {@link String} to milliseconds in a "static"
* way (to exchange data over the wire, for instance).
*
* @param time
* the time as a {@link String}
*
* @return the time in milliseconds
*/
static public long toTime(String display) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
return sdf.parse(display).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 Base64 representation
*
* @throws IOException
* in case of IO 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 {@link File} image into a Base64 representation of the
* same {@link File}.
*
* @param file
* the {@link File} 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);
}
/**
* Return a hash of the given {@link String}.
*
* @param input
* the input data
*
* @return the hash
*/
static public String getHash(String input) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(input.getBytes());
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;
}
}
/**
* Remove the HTML content from the given input, and un-html-ize the rest.
*
* @param html
* the HTML-encoded content
*
* @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);
}
}
return HtmlEscape.unescapeHtml(builder.toString());
}
/**
* Escape the given {@link String} so it can be used in XML, as content.
*
* @param input
* the input {@link String}
*
* @return the escaped {@link String}
*/
public static String xmlEscape(String input) {
if (input == null) {
return "";
}
return HtmlEscape.escapeHtml(input,
HtmlEscapeType.HTML4_NAMED_REFERENCES_DEFAULT_TO_HEXA,
HtmlEscapeLevel.LEVEL_1_ONLY_MARKUP_SIGNIFICANT);
}
/**
* 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 "";
}
return HtmlEscape.escapeHtml(input,
HtmlEscapeType.HTML4_NAMED_REFERENCES_DEFAULT_TO_HEXA,
HtmlEscapeLevel.LEVEL_1_ONLY_MARKUP_SIGNIFICANT);
}
}