X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Futil%2FStringUtils.java;h=11a108866e2ebc28b5c0fab16e41138ec6abb748;hb=c932f0e85a8852824cdd8ce790af68682732c85c;hp=2e8ace8b8e45a6f75d6148e50e244e88f94ca1e6;hpb=14193747f3831242bc7dfac12394eb20eb0ba480;p=jalview.git diff --git a/src/jalview/util/StringUtils.java b/src/jalview/util/StringUtils.java index 2e8ace8..11a1088 100644 --- a/src/jalview/util/StringUtils.java +++ b/src/jalview/util/StringUtils.java @@ -20,8 +20,12 @@ */ package jalview.util; +import java.io.UnsupportedEncodingException; +import java.net.URLEncoder; import java.util.ArrayList; import java.util.List; +import java.util.Locale; +import java.util.regex.Matcher; import java.util.regex.Pattern; public class StringUtils @@ -29,8 +33,16 @@ public class StringUtils private static final Pattern DELIMITERS_PATTERN = Pattern .compile(".*='[^']*(?!')"); + private static final char PERCENT = '%'; + private static final boolean DEBUG = false; + /* + * URL encoded characters, indexed by char value + * e.g. urlEncodings['='] = urlEncodings[61] = "%3D" + */ + private static String[] urlEncodings = new String[255]; + /** * Returns a new character array, after inserting characters into the given * character array. @@ -146,7 +158,7 @@ public class StringUtils { return null; } - List jv = new ArrayList(); + List jv = new ArrayList<>(); int cp = 0, pos, escape; boolean wasescaped = false, wasquoted = false; String lstitem = null; @@ -190,18 +202,18 @@ public class StringUtils jv.clear(); if (DEBUG) { - System.err.println("Array from '" + delimiter + jalview.bin.Console.errPrintln("Array from '" + delimiter + "' separated List:\n" + v.length); for (int i = 0; i < v.length; i++) { - System.err.println("item " + i + " '" + v[i] + "'"); + jalview.bin.Console.errPrintln("item " + i + " '" + v[i] + "'"); } } return v; } if (DEBUG) { - System.err.println( + jalview.bin.Console.errPrintln( "Empty Array from '" + delimiter + "' separated List"); } return null; @@ -237,13 +249,13 @@ public class StringUtils { System.err .println("Returning '" + separator + "' separated List:\n"); - System.err.println(v); + jalview.bin.Console.errPrintln(v); } return v.toString(); } if (DEBUG) { - System.err.println( + jalview.bin.Console.errPrintln( "Returning empty '" + separator + "' separated List\n"); } return "" + separator; @@ -399,9 +411,10 @@ public class StringUtils } if (s.length() <= 1) { - return s.toUpperCase(); + return s.toUpperCase(Locale.ROOT); } - return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase(); + return s.substring(0, 1).toUpperCase(Locale.ROOT) + + s.substring(1).toLowerCase(Locale.ROOT); } /** @@ -417,7 +430,7 @@ public class StringUtils { return null; } - String tmp2up = text.toUpperCase(); + String tmp2up = text.toUpperCase(Locale.ROOT); int startTag = tmp2up.indexOf(""); if (startTag > -1) { @@ -436,7 +449,7 @@ public class StringUtils { text = text.substring(0, endTag); } - + if (startTag == -1 && (text.contains("<") || text.contains(">"))) { text = text.replaceAll("<", "<"); @@ -444,4 +457,182 @@ public class StringUtils } return text; } + + /** + * Answers the input string with any occurrences of the 'encodeable' + * characters replaced by their URL encoding + * + * @param s + * @param encodable + * @return + */ + public static String urlEncode(String s, String encodable) + { + if (s == null || s.isEmpty()) + { + return s; + } + + /* + * do % encoding first, as otherwise it may double-encode! + */ + if (encodable.indexOf(PERCENT) != -1) + { + s = urlEncode(s, PERCENT); + } + + for (char c : encodable.toCharArray()) + { + if (c != PERCENT) + { + s = urlEncode(s, c); + } + } + return s; + } + + /** + * Answers the input string with any occurrences of {@code c} replaced with + * their url encoding. Answers the input string if it is unchanged. + * + * @param s + * @param c + * @return + */ + static String urlEncode(String s, char c) + { + String decoded = String.valueOf(c); + if (s.indexOf(decoded) != -1) + { + String encoded = getUrlEncoding(c); + if (!encoded.equals(decoded)) + { + s = s.replace(decoded, encoded); + } + } + return s; + } + + /** + * Answers the input string with any occurrences of the specified (unencoded) + * characters replaced by their URL decoding. + *

+ * Example: {@code urlDecode("a%3Db%3Bc", "-;=,")} should answer + * {@code "a=b;c"}. + * + * @param s + * @param encodable + * @return + */ + public static String urlDecode(String s, String encodable) + { + if (s == null || s.isEmpty()) + { + return s; + } + + for (char c : encodable.toCharArray()) + { + String encoded = getUrlEncoding(c); + if (s.indexOf(encoded) != -1) + { + String decoded = String.valueOf(c); + s = s.replace(encoded, decoded); + } + } + return s; + } + + /** + * Does a lazy lookup of the url encoding of the given character, saving the + * value for repeat lookups + * + * @param c + * @return + */ + private static String getUrlEncoding(char c) + { + if (c < 0 || c >= urlEncodings.length) + { + return String.valueOf(c); + } + + String enc = urlEncodings[c]; + if (enc == null) + { + try + { + enc = urlEncodings[c] = URLEncoder.encode(String.valueOf(c), + "UTF-8"); + } catch (UnsupportedEncodingException e) + { + enc = urlEncodings[c] = String.valueOf(c); + } + } + return enc; + } + + public static int firstCharPosIgnoreCase(String text, String chars) + { + int min = text.length() + 1; + for (char c : chars.toLowerCase(Locale.ROOT).toCharArray()) + { + int i = text.toLowerCase(Locale.ROOT).indexOf(c); + if (0 <= i && i < min) + { + min = i; + } + } + return min < text.length() + 1 ? min : -1; + } + + public static int indexOfFirstWhitespace(String text) + { + int index = -1; + Pattern pat = Pattern.compile("\\s"); + Matcher m = pat.matcher(text); + if (m.find()) + { + index = m.start(); + } + return index; + } + + /* + * implementation of String.replaceLast. + * Replaces only the last occurrence of toReplace in string with replacement. + */ + public static String replaceLast(String string, String toReplace, + String replacement) + { + int pos = string.lastIndexOf(toReplace); + if (pos > -1) + { + return new StringBuilder().append(string.substring(0, pos)) + .append(replacement) + .append(string.substring(pos + toReplace.length())) + .toString(); + } + else + { + return string; + } + + } + + /* + * return the maximum length of a List of Strings + */ + public static int maxLength(List l) + { + int max = 0; + for (String s : l) + { + if (s == null) + continue; + if (s.length() > max) + max = s.length(); + } + return max; + } }