| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2007 IBM Corporation and others. |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v1.0 |
| // which accompanies this distribution, and is available at |
| // http://www.eclipse.org/legal/epl-v10.html |
| // |
| // Contributors: |
| // IBM Corporation - initial implementation |
| //------------------------------------------------------------------------------ |
| package org.eclipse.epf.common.utils; |
| |
| import java.net.URI; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.epf.common.CommonPlugin; |
| |
| import com.ibm.icu.lang.UCharacter; |
| import com.ibm.icu.util.StringTokenizer; |
| |
| /** |
| * A helper class for manuipulating strings. |
| * |
| * @author Kelvin Low |
| * @author Jinhua Xi |
| * @since 1.0 |
| */ |
| public class StrUtil { |
| public static final String EMPTY_STRING = ""; //$NON-NLS-1$ |
| |
| public static final String TAB = "\t"; //$NON-NLS-1$ |
| |
| private static final String REGEXP_ANY_SPECIAL_CHARS = "(`|~|!|@|#|\\$|%|\\^|&|\\*|\\(|\\)|\\+|=|\\[|\\]|\\||\\:|\"|<|>|\\?|/|'|\\s|\\\\)+"; //$NON-NLS-1$ |
| |
| private static final String REGEXP_INVALID_PUBLISHED_PATH_CHARS = "(\\[|#|\\*|\\?|\"|<|>|\\||!|%|/|\\])+"; //$NON-NLS-1$ |
| |
| private static final String REGEXP_INVALID_PUBLISHED_PATH_CHARS_LINUX = "(\\[|#|\\*|\\?|\"|<|>|\\||!|%|\\])+"; //$NON-NLS-1$ |
| |
| private static final String REGEXP_INVALID_FILENAME_CHARS = "(\\[|#|/|\\\\|\\:|\\*|\\?|\"|<|>|\\||\\]|\\s)+"; //$NON-NLS-1$ |
| |
| private static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', |
| '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; |
| |
| public static final String LINE_FEED = System.getProperty("line.separator"); //$NON-NLS-1$ |
| |
| public static final String ESCAPED_LF = "
"; //$NON-NLS-1$ |
| |
| public static final String ESCAPED_CR = "
"; //$NON-NLS-1$ |
| |
| public static final String ESCAPED_LINE_FEED = LINE_FEED.replace( |
| "\n", ESCAPED_LF).replace("\r", ESCAPED_CR); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| public static final String LINE_FEED_REGEX = LINE_FEED.replaceAll( |
| "\\\\", "\\\\"); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| public static final String ESCAPED_LINE_FEED_REGEX = ESCAPED_LINE_FEED; |
| |
| public static final String HTML_BREAK = "<br/>";//$NON-NLS-1$ |
| |
| public static final String HTML_COPY = "©";//$NON-NLS-1$ |
| |
| public static final String HTML_EURO = "€";//$NON-NLS-1$ |
| |
| public static final String HTML_REG = "®";//$NON-NLS-1$ |
| |
| public static final String HTML_TRADEMARK = "™";//$NON-NLS-1$ |
| |
| public static boolean during_migration = false; |
| |
| private static StrUtilOptions options; |
| |
| /** |
| * Private constructor to prevent this class from being instantiated. All |
| * methods in this class should be static. |
| */ |
| private StrUtil() { |
| } |
| |
| /** |
| * Tests for null string. |
| * <p> |
| * A null string is defined as one that has an empty reference or has zero |
| * length. |
| * |
| * @param str |
| * a string |
| * @return <code>true</code> if the given string is a null string |
| */ |
| public static boolean isNull(String str) { |
| return str == null || str.length() == 0; |
| } |
| |
| /** |
| * Tests for blank string. |
| * <p> |
| * A blank string is defined as one that has an empty reference or has zero |
| * length after the leading and trailing space characters are trimmed. |
| * |
| * @param str |
| * a string |
| * @return <code>true</code> if the given string is a blank string |
| */ |
| public static boolean isBlank(String str) { |
| return str == null || str.trim().length() == 0; |
| } |
| |
| /** |
| * Removes the leading and trailing space characters from a string. |
| * |
| * @param str |
| * a string |
| * @return a string with no leading and trailing space characters |
| */ |
| public static String trim(String str) { |
| return str == null ? null : str.trim(); |
| } |
| |
| /** |
| * Removes whitespace characters (TAB, CR, LF and SPACE) from a string. |
| * |
| * @param str |
| * a string |
| * @return a string with whitespace characters removed |
| */ |
| public static String removeWhiteSpaceChars(String str) { |
| int len = (str == null) ? 0 : str.length(); |
| for (int i = 0; i < len; i++) { |
| switch (str.charAt(i)) { |
| case '\t': |
| case '\r': |
| case '\n': |
| case ' ': |
| break; |
| default: |
| return str; |
| } |
| } |
| return ""; //$NON-NLS-1$ |
| } |
| |
| /** |
| * Removes CR, LF from a string. |
| * |
| * @param str |
| * a string |
| * @return a string with CR, LF removed |
| */ |
| public static String removeNewlines(String str) { |
| StringBuffer sb = new StringBuffer(); |
| int len = (str == null) ? 0 : str.length(); |
| for (int i = 0; i < len; i++) { |
| char c = str.charAt(i); |
| switch (c) { |
| case '\r': |
| case '\n': |
| break; |
| default: |
| sb.append(c); |
| } |
| } |
| return sb.toString(); |
| } |
| |
| /** |
| * Splits a string into an array of string tokens. |
| * |
| * @param str |
| * a string |
| * @param sep |
| * a string containing the string separators |
| * @param count |
| * the desired number of string tokens |
| * @return an array of string tokens |
| */ |
| public static String[] split(String str, String sep, int count) { |
| if (str == null || count == 0 || count < -1) { |
| return null; |
| } |
| |
| StringTokenizer tokenizer = new StringTokenizer(str, sep, |
| count == -1 ? false : true); |
| |
| if (count == -1) { |
| count = tokenizer.countTokens(); |
| } |
| |
| String[] result = new String[count]; |
| int i = 0; |
| while (tokenizer.hasMoreTokens()) { |
| String t = tokenizer.nextToken(); |
| if (i < count) { |
| if ((t.length() == 1) && (sep.indexOf(t) != -1)) { |
| continue; |
| } |
| result[i++] = t; |
| } else { |
| result[count - 1] += t; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Splits a string into an array of string tokens. |
| * |
| * @param str |
| * a string |
| * @param sep |
| * a string containing the string separators |
| * @return an array of string tokens |
| */ |
| public static String[] split(String str, String sep) { |
| return split(str, sep, -1); |
| } |
| |
| /** |
| * Replaces a substring within a string with another substring. |
| * <p> |
| * Note: Only the first occurrence of the substring will be replaced. |
| * |
| * @param str |
| * a string |
| * @param src |
| * the substring to replace |
| * @param tgt |
| * the substring to use for the replacement |
| * @return a string with the first substring replaced |
| * |
| * TODO: Review implementation. Call String.replaceFirst() instead? |
| */ |
| public static String replace(String str, String src, String tgt) { |
| if ((str == null || str.length() == 0) |
| || (src == null || src.length() == 0)) { |
| return str; |
| } |
| |
| String tmpStr = str; |
| int index; |
| while ((index = tmpStr.indexOf(src)) != -1) { |
| tmpStr = tmpStr.substring(0, index) + tgt |
| + tmpStr.substring(index + src.length()); |
| } |
| return tmpStr; |
| } |
| |
| /** |
| * Returns the integer value of a string. |
| * |
| * @param str |
| * a string |
| * @param defaultValue |
| * a default integer value for the string |
| * @return the integer value of the given string |
| */ |
| public static int getIntValue(String str, int defaultValue) { |
| if (StrUtil.isBlank(str)) { |
| return defaultValue; |
| } |
| |
| try { |
| return Integer.parseInt(str); |
| } catch (NumberFormatException e) { |
| return defaultValue; |
| } |
| } |
| |
| /** |
| * Returns an array of bytes representing the UTF-8 encoding of a string. |
| * |
| * @param str |
| * a string |
| * @return a byte array containing the UTF-8 encoding of the given string |
| */ |
| public static byte[] getUTF8Bytes(String str) { |
| char[] c = str.toCharArray(); |
| int len = c.length; |
| int count = 0; |
| for (int i = 0; i < len; i++) { |
| int ch = c[i]; |
| if (ch <= 0x7f) { |
| count++; |
| } else if (ch <= 0x7ff) { |
| count += 2; |
| } else { |
| count += 3; |
| } |
| } |
| |
| byte[] b = new byte[count]; |
| int off = 0; |
| for (int i = 0; i < len; i++) { |
| int ch = c[i]; |
| if (ch <= 0x7f) { |
| b[off++] = (byte) ch; |
| } else if (ch <= 0x7ff) { |
| b[off++] = (byte) ((ch >> 6) | 0xc0); |
| b[off++] = (byte) ((ch & 0x3f) | 0x80); |
| } else { |
| b[off++] = (byte) ((ch >> 12) | 0xe0); |
| b[off++] = (byte) (((ch >> 6) & 0x3f) | 0x80); |
| b[off++] = (byte) ((ch & 0x3f) | 0x80); |
| } |
| } |
| return b; |
| } |
| |
| /** |
| * Returns the hexidecimal character representation for an integer. |
| * |
| * @param value |
| * an integer |
| * @return the hexidecimal representation |
| */ |
| private static char toHex(int value) { |
| return HEX_DIGITS[(value & 0xF)]; |
| } |
| |
| /** |
| * Returns the escaped Unicode representation of a string. |
| * |
| * @param str |
| * a string |
| * @param skipASCII |
| * if <code>true</code>, avoid escaping the ASCII characters |
| * @return the escaped Unicode representation of the given string |
| */ |
| public static String toEscapedUnicode(String str, boolean skipASCII) { |
| int len = str.length(); |
| StringBuffer result = new StringBuffer(len * 2); |
| |
| for (int i = 0; i < len; i++) { |
| char ch = str.charAt(i); |
| |
| if (skipASCII && ch < 0x007E) { |
| result.append(ch); |
| } else { |
| result.append("\\u"); //$NON-NLS-1$ |
| result.append(toHex((ch >> 12) & 0xF)); |
| result.append(toHex((ch >> 8) & 0xF)); |
| result.append(toHex((ch >> 4) & 0xF)); |
| result.append(toHex(ch & 0xF)); |
| } |
| } |
| |
| return result.toString(); |
| } |
| |
| /** |
| * Returns the escaped HTML representation of a string. |
| * |
| * @param html |
| * a HTML string |
| * @return the escaped Unicode representation of the given HTML string |
| */ |
| public static String getEscapedHTML(String html) { |
| if (html == null || html.length() == 0) { |
| return ""; //$NON-NLS-1$ |
| } |
| |
| StrUtilOptions options = getOptions(); |
| StringBuffer result = new StringBuffer(); |
| int length = html.length(); |
| for (int i = 0; i < length; i++) { |
| char ch = html.charAt(i); |
| switch (ch) { |
| case '%': |
| if (i + 4 < length) { |
| String hexStr = html.substring(i + 1, i + 5); |
| boolean validHextStr = true; |
| |
| for (int j = 0; j < hexStr.length(); j++) { |
| char c = hexStr.charAt(j); |
| if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) { |
| validHextStr = false; |
| break; |
| } |
| } |
| |
| if (options == null) { |
| //code below will treat "%20de" as " de" |
| //this may lose some double bytes character(e.g. Chinese), which start with %20, but keep all url links |
| //so far open this convertion not only during library migration to support file like "my design.gif" |
| if (/*during_migration && */validHextStr) { |
| if (hexStr.startsWith("20")) { //$NON-NLS-1$ |
| result.append("%20"); //$NON-NLS-1$ |
| i += 2; |
| break; |
| } |
| } |
| } else { |
| int ix = options.getRteUrlDecodingOption(); |
| if (ix == 1) { |
| validHextStr = false; |
| } else if (ix == 2) { |
| String key = getHexStr("%" + hexStr); |
| if (key != null && options.getRteUrlDecodingHexMap().containsKey(key)) { |
| validHextStr = false; |
| } |
| } |
| } |
| |
| if (validHextStr) { |
| try { |
| int codePoint = Integer.parseInt(hexStr, 16); |
| char[] c = UCharacter.toChars(codePoint); |
| result.append(c); |
| i += 4; |
| break; |
| } catch (NumberFormatException e) { |
| // wasn't a valid hex string.. |
| // fall through to the result.append(ch) |
| } catch (Exception e) { |
| CommonPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| } |
| result.append(ch); |
| break; |
| case '\u00a9': |
| result.append(HTML_COPY); |
| break; |
| case '\u00ae': |
| result.append(HTML_REG); |
| break; |
| case '\u20ac': |
| result.append(HTML_EURO); |
| break; |
| case '\u2122': |
| result.append(HTML_TRADEMARK); |
| break; |
| default: |
| result.append(ch); |
| break; |
| } |
| } |
| return result.toString(); |
| } |
| |
| /** |
| * Returns the plain text from HTML text. |
| * <p> |
| * Note: All HTML tags will be stripped. |
| * |
| * @param html |
| * the HTML text. |
| * @return the plain text representation of the given HTML text |
| */ |
| public static String getPlainText(String html) { |
| if (html == null) { |
| return ""; //$NON-NLS-1$ |
| } |
| |
| final Pattern p_plaintext_filter = Pattern.compile( |
| "<[^>]*?>", Pattern.CASE_INSENSITIVE | Pattern.DOTALL); //$NON-NLS-1$ |
| final Pattern p_plaintext_filter2 = Pattern.compile( |
| "&.{1,5}[^;];", Pattern.CASE_INSENSITIVE | Pattern.DOTALL); //$NON-NLS-1$ |
| final Pattern p_plaintext_filter3 = Pattern.compile( |
| "\\s+", Pattern.CASE_INSENSITIVE | Pattern.DOTALL); //$NON-NLS-1$ |
| |
| String result = html.replaceAll(p_plaintext_filter.pattern(), " ") //$NON-NLS-1$ |
| .replaceAll(p_plaintext_filter2.pattern(), " ") //$NON-NLS-1$ |
| .replaceAll(p_plaintext_filter3.pattern(), " "); //$NON-NLS-1$ |
| return result; |
| } |
| |
| /** |
| * Converts a string into a valid file name. |
| * |
| * @param str |
| * a string |
| * @return a valid file name derived from the given string |
| */ |
| public static String makeValidFileName(String str) { |
| if (str == null) { |
| return ""; //$NON-NLS-1$ |
| } |
| return getPlainText(str) |
| .replaceAll(REGEXP_INVALID_FILENAME_CHARS, " ").trim(); //$NON-NLS-1$ |
| } |
| |
| public static String removeSpecialCharacters(String str) { |
| if (str == null) { |
| return ""; //$NON-NLS-1$ |
| } |
| return getPlainText(str) |
| .replaceAll(REGEXP_ANY_SPECIAL_CHARS, " ").trim(); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Returns true if the path does not contain any invalid filename |
| * characters. |
| * |
| * @param path |
| * the file path |
| * @return <code>true</code> if the given path contains only valid |
| * filename characters |
| */ |
| public static boolean isValidPublishPath(String path) { |
| // return path.replaceAll(invalidPublishPathCharsRegExp, |
| // "").equals(path); |
| |
| if (Platform.getOS().equals(Platform.WS_WIN32)) { |
| return path |
| .replaceAll(REGEXP_INVALID_PUBLISHED_PATH_CHARS, "").equals(path); //$NON-NLS-1$ |
| } |
| |
| // else default to Linux |
| return path |
| .replaceAll(REGEXP_INVALID_PUBLISHED_PATH_CHARS_LINUX, "").equals(path); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Returns the lower-case of str unless the current locale is German |
| * |
| * @param str |
| * @return |
| */ |
| public static String toLower(String str) { |
| if (Platform.getNL().startsWith("de")) { //$NON-NLS-1$ |
| return str; |
| } |
| return str.toLowerCase(); |
| } |
| |
| /** |
| * escape the " and ' |
| * |
| * @param str |
| * @return |
| */ |
| public static String escape(String str) { |
| return str.replaceAll("'", "\\\\\'").replaceAll("\"", "\\\\\""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ |
| } |
| |
| /** |
| * Converts a <code>List</code> to an String array. |
| * |
| * @param list |
| * a <code>List</code> |
| * @return a String array |
| */ |
| public static String[] convertListToStrArray(List list) { |
| if (list != null) { |
| int cnt = list.size(); |
| String[] strArray = new String[cnt]; |
| |
| for (int i = 0; i < cnt; i++) { |
| String str = (String) list.get(i); |
| strArray[i] = new String(str); |
| } |
| return strArray; |
| } else { |
| return null; |
| } |
| } |
| |
| public static boolean isValidName(String name) { |
| return name.replaceAll(REGEXP_ANY_SPECIAL_CHARS, "").equals(name); //$NON-NLS-1$ |
| } |
| |
| /** |
| * added some test code |
| * |
| * @param args |
| */ |
| public static void main(String[] args) { |
| |
| String text = "A&% `&# $~!@#$%^&*()_-+={}[\"]:|\\:;\"'<,>.?/ \t\r\nZ"; //$NON-NLS-1$ |
| |
| System.out.println("[" + text + "] <== text"); //$NON-NLS-1$ //$NON-NLS-2$ |
| System.out.println("[" + text.replaceAll(REGEXP_ANY_SPECIAL_CHARS, " ") //$NON-NLS-1$ //$NON-NLS-2$ |
| + "] <== All"); //$NON-NLS-1$ |
| System.out.println("[" //$NON-NLS-1$ |
| + text.replaceAll(REGEXP_INVALID_FILENAME_CHARS, " ") //$NON-NLS-1$ |
| + "] <== File Name"); //$NON-NLS-1$ |
| System.out.println("[" //$NON-NLS-1$ |
| + text.replaceAll(REGEXP_INVALID_PUBLISHED_PATH_CHARS, " ") //$NON-NLS-1$ |
| + "] <== path"); //$NON-NLS-1$ |
| System.out.println("[" //$NON-NLS-1$ |
| + text.replaceAll(REGEXP_INVALID_PUBLISHED_PATH_CHARS_LINUX, |
| " ") + "] <== path, Linux"); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| System.out.println(""); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Converts the platform line-separator (\n or \n\r or \r) to <br/> |
| * |
| * @param text |
| * @return |
| */ |
| public static String convertNewlinesToHTML(String text) { |
| if (text != null) { |
| text = text.replaceAll(LINE_FEED_REGEX, HTML_BREAK + LINE_FEED); |
| text = text.replaceAll(ESCAPED_LINE_FEED_REGEX, HTML_BREAK |
| + ESCAPED_LINE_FEED); |
| } |
| return text; |
| } |
| |
| public static URI toURI(String pathStr) { |
| if (pathStr != null && pathStr.length() > 0) { |
| IPath path = Path.fromOSString(pathStr); |
| try { |
| return path.toFile().toURI(); |
| } catch (Exception e) { |
| CommonPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| return null; |
| } |
| |
| public static String escapeChar(String text, char c) { |
| int i=text.indexOf(c); |
| if ( i < 0 ) { |
| return text; |
| } |
| |
| int start = 0; |
| StringBuffer buffer = new StringBuffer(); |
| while ( i > start ) { |
| buffer.append(text.substring(start, i)).append("\\"); //$NON-NLS-1$ |
| start = i; |
| i=text.indexOf(c, start+1); |
| } |
| |
| buffer.append(text.substring(start)); |
| |
| return buffer.toString(); |
| } |
| |
| public static String getHexStr(String str) { |
| if (str.length() < 3) { |
| return null; |
| } |
| if (str.charAt(0) != '%') { |
| return null; |
| } |
| StringBuffer b = new StringBuffer(); |
| b.append('%'); |
| for (int i = 1 ; i <= 2; i++) { |
| char c = str.charAt(i); |
| if (c >= 'a' && c <= 'z') { |
| c -= 'a'; |
| c += 'A'; |
| } |
| boolean valid = (c >= '0' && c <= '9') || |
| (c >= 'A' && c <= 'F'); |
| if (!valid) { |
| return null; |
| } |
| b.append(c); |
| } |
| |
| return b.toString(); |
| } |
| |
| public interface StrUtilOptions { |
| int getRteUrlDecodingOption(); |
| Map<String, String> getRteUrlDecodingHexMap(); |
| } |
| |
| public static StrUtilOptions getOptions() { |
| return options; |
| } |
| |
| public static void setOptions(StrUtilOptions options) { |
| StrUtil.options = options; |
| } |
| |
| } |
