// *************************************************************************************************************************** | |
// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * | |
// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * | |
// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * | |
// * with the License. You may obtain a copy of the License at * | |
// * * | |
// * http://www.apache.org/licenses/LICENSE-2.0 * | |
// * * | |
// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * | |
// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * | |
// * specific language governing permissions and limitations under the License. * | |
// *************************************************************************************************************************** | |
package org.apache.juneau.internal; | |
import static org.apache.juneau.internal.ThrowableUtils.*; | |
import java.io.*; | |
import java.lang.reflect.*; | |
import java.math.*; | |
import java.net.*; | |
import java.nio.*; | |
import java.nio.charset.*; | |
import java.text.*; | |
import java.util.*; | |
import java.util.concurrent.atomic.*; | |
import java.util.regex.*; | |
import javax.xml.bind.*; | |
import org.apache.juneau.*; | |
import org.apache.juneau.json.*; | |
import org.apache.juneau.parser.*; | |
import org.apache.juneau.parser.ParseException; | |
/** | |
* Reusable string utility methods. | |
*/ | |
public final class StringUtils { | |
private static final AsciiSet numberChars = new AsciiSet("-xX.+-#pP0123456789abcdefABCDEF"); | |
private static final AsciiSet firstNumberChars = new AsciiSet("+-.#0123456789"); | |
private static final AsciiSet octChars = new AsciiSet("01234567"); | |
private static final AsciiSet decChars = new AsciiSet("0123456789"); | |
private static final AsciiSet hexChars = new AsciiSet("0123456789abcdefABCDEF"); | |
// Maps 6-bit nibbles to BASE64 characters. | |
private static final char[] base64m1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray(); | |
// Characters that do not need to be URL-encoded | |
private static final AsciiSet unencodedChars = new AsciiSet("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.!~*'()\\"); | |
// Maps BASE64 characters to 6-bit nibbles. | |
private static final byte[] base64m2 = new byte[128]; | |
static { | |
for (int i = 0; i < 64; i++) | |
base64m2[base64m1[i]] = (byte)i; | |
} | |
/** | |
* Parses a number from the specified reader stream. | |
* | |
* @param r The reader to parse the string from. | |
* @param type | |
* The number type to created. | |
* Can be any of the following: | |
* <ul> | |
* <li> Integer | |
* <li> Double | |
* <li> Float | |
* <li> Long | |
* <li> Short | |
* <li> Byte | |
* <li> BigInteger | |
* <li> BigDecimal | |
* </ul> | |
* If <jk>null</jk>, uses the best guess. | |
* @throws IOException If a problem occurred trying to read from the reader. | |
* @return The parsed number. | |
* @throws Exception | |
*/ | |
public static Number parseNumber(ParserReader r, Class<? extends Number> type) throws Exception { | |
return parseNumber(parseNumberString(r), type); | |
} | |
/** | |
* Reads a numeric string from the specified reader. | |
* | |
* @param r The reader to read form. | |
* @return The parsed number string. | |
* @throws Exception | |
*/ | |
public static String parseNumberString(ParserReader r) throws Exception { | |
r.mark(); | |
int c = 0; | |
while (true) { | |
c = r.read(); | |
if (c == -1) | |
break; | |
if (! numberChars.contains((char)c)) { | |
r.unread(); | |
break; | |
} | |
} | |
return r.getMarked(); | |
} | |
/** | |
* Parses a number from the specified string. | |
* | |
* @param s The string to parse the number from. | |
* @param type | |
* The number type to created. | |
* Can be any of the following: | |
* <ul> | |
* <li> Integer | |
* <li> Double | |
* <li> Float | |
* <li> Long | |
* <li> Short | |
* <li> Byte | |
* <li> BigInteger | |
* <li> BigDecimal | |
* </ul> | |
* If <jk>null</jk> or <code>Number</code>, uses the best guess. | |
* @return The parsed number, or <jk>null</jk> if the string was null. | |
* @throws ParseException | |
*/ | |
public static Number parseNumber(String s, Class<? extends Number> type) throws ParseException { | |
if (s == null) | |
return null; | |
if (s.isEmpty()) | |
s = "0"; | |
if (type == null) | |
type = Number.class; | |
try { | |
// Determine the data type if it wasn't specified. | |
boolean isAutoDetect = (type == Number.class); | |
boolean isDecimal = false; | |
if (isAutoDetect) { | |
// If we're auto-detecting, then we use either an Integer, Long, or Double depending on how | |
// long the string is. | |
// An integer range is -2,147,483,648 to 2,147,483,647 | |
// An long range is -9,223,372,036,854,775,808 to +9,223,372,036,854,775,807 | |
isDecimal = isDecimal(s); | |
if (isDecimal) { | |
if (s.length() > 20) | |
type = Double.class; | |
else if (s.length() >= 10) | |
type = Long.class; | |
else | |
type = Integer.class; | |
} | |
else if (isFloat(s)) | |
type = Double.class; | |
else | |
throw new NumberFormatException(s); | |
} | |
if (type == Double.class || type == Double.TYPE) { | |
Double d = Double.valueOf(s); | |
Float f = Float.valueOf(s); | |
if (isAutoDetect && (!isDecimal) && d.toString().equals(f.toString())) | |
return f; | |
return d; | |
} | |
if (type == Float.class || type == Float.TYPE) | |
return Float.valueOf(s); | |
if (type == BigDecimal.class) | |
return new BigDecimal(s); | |
if (type == Long.class || type == Long.TYPE || type == AtomicLong.class) { | |
try { | |
Long l = Long.decode(s); | |
if (type == AtomicLong.class) | |
return new AtomicLong(l); | |
if (isAutoDetect && l >= Integer.MIN_VALUE && l <= Integer.MAX_VALUE) { | |
// This occurs if the string is 10 characters long but is still a valid integer value. | |
return l.intValue(); | |
} | |
return l; | |
} catch (NumberFormatException e) { | |
if (isAutoDetect) { | |
// This occurs if the string is 20 characters long but still falls outside the range of a valid long. | |
return Double.valueOf(s); | |
} | |
throw e; | |
} | |
} | |
if (type == Integer.class || type == Integer.TYPE) | |
return Integer.decode(s); | |
if (type == Short.class || type == Short.TYPE) | |
return Short.decode(s); | |
if (type == Byte.class || type == Byte.TYPE) | |
return Byte.decode(s); | |
if (type == BigInteger.class) | |
return new BigInteger(s); | |
if (type == AtomicInteger.class) | |
return new AtomicInteger(Integer.decode(s)); | |
throw new ParseException("Unsupported Number type: {0}", type.getName()); | |
} catch (NumberFormatException e) { | |
throw new ParseException("Invalid number: ''{0}'', class=''{1}''", s, type.getSimpleName()).initCause(e); | |
} | |
} | |
private static final Pattern fpRegex = Pattern.compile( | |
"[+-]?(NaN|Infinity|((((\\p{Digit}+)(\\.)?((\\p{Digit}+)?)([eE][+-]?(\\p{Digit}+))?)|(\\.((\\p{Digit}+))([eE][+-]?(\\p{Digit}+))?)|(((0[xX](\\p{XDigit}+)(\\.)?)|(0[xX](\\p{XDigit}+)?(\\.)(\\p{XDigit}+)))[pP][+-]?(\\p{Digit}+)))[fFdD]?))[\\x00-\\x20]*" | |
); | |
/** | |
* Returns <jk>true</jk> if this string can be parsed by {@link #parseNumber(String, Class)}. | |
* | |
* @param s The string to check. | |
* @return <jk>true</jk> if this string can be parsed without causing an exception. | |
*/ | |
public static boolean isNumeric(String s) { | |
if (s == null || s.isEmpty()) | |
return false; | |
if (! isFirstNumberChar(s.charAt(0))) | |
return false; | |
return isDecimal(s) || isFloat(s); | |
} | |
/** | |
* Returns <jk>true</jk> if the specified character is a valid first character for a number. | |
* | |
* @param c The character to test. | |
* @return <jk>true</jk> if the specified character is a valid first character for a number. | |
*/ | |
public static boolean isFirstNumberChar(char c) { | |
return firstNumberChars.contains(c); | |
} | |
/** | |
* Returns <jk>true</jk> if the specified string is a floating point number. | |
* | |
* @param s The string to check. | |
* @return <jk>true</jk> if the specified string is a floating point number. | |
*/ | |
public static boolean isFloat(String s) { | |
if (s == null || s.isEmpty()) | |
return false; | |
if (! firstNumberChars.contains(s.charAt(0))) | |
return (s.equals("NaN") || s.equals("Infinity")); | |
int i = 0; | |
int length = s.length(); | |
char c = s.charAt(0); | |
if (c == '+' || c == '-') | |
i++; | |
if (i == length) | |
return false; | |
c = s.charAt(i++); | |
if (c == '.' || decChars.contains(c)) { | |
return fpRegex.matcher(s).matches(); | |
} | |
return false; | |
} | |
/** | |
* Returns <jk>true</jk> if the specified string is numeric. | |
* | |
* @param s The string to check. | |
* @return <jk>true</jk> if the specified string is numeric. | |
*/ | |
public static boolean isDecimal(String s) { | |
if (s == null || s.isEmpty()) | |
return false; | |
if (! firstNumberChars.contains(s.charAt(0))) | |
return false; | |
int i = 0; | |
int length = s.length(); | |
char c = s.charAt(0); | |
boolean isPrefixed = false; | |
if (c == '+' || c == '-') { | |
isPrefixed = true; | |
i++; | |
} | |
if (i == length) | |
return false; | |
c = s.charAt(i++); | |
if (c == '0' && length > (isPrefixed ? 2 : 1)) { | |
c = s.charAt(i++); | |
if (c == 'x' || c == 'X') { | |
for (int j = i; j < length; j++) { | |
if (! hexChars.contains(s.charAt(j))) | |
return false; | |
} | |
} else if (octChars.contains(c)) { | |
for (int j = i; j < length; j++) | |
if (! octChars.contains(s.charAt(j))) | |
return false; | |
} else { | |
return false; | |
} | |
} else if (c == '#') { | |
for (int j = i; j < length; j++) { | |
if (! hexChars.contains(s.charAt(j))) | |
return false; | |
} | |
} else if (decChars.contains(c)) { | |
for (int j = i; j < length; j++) | |
if (! decChars.contains(s.charAt(j))) | |
return false; | |
} else { | |
return false; | |
} | |
return true; | |
} | |
/** | |
* Convenience method for getting a stack trace as a string. | |
* | |
* @param t The throwable to get the stack trace from. | |
* @return The same content that would normally be rendered via <code>t.printStackTrace()</code> | |
*/ | |
public static String getStackTrace(Throwable t) { | |
StringWriter sw = new StringWriter(); | |
try (PrintWriter pw = new PrintWriter(sw)) { | |
t.printStackTrace(pw); | |
} | |
return sw.toString(); | |
} | |
/** | |
* Join the specified tokens into a delimited string. | |
* | |
* @param tokens The tokens to join. | |
* @param separator The delimiter. | |
* @return The delimited string. If <code>tokens</code> is <jk>null</jk>, returns <jk>null</jk>. | |
*/ | |
public static String join(Object[] tokens, String separator) { | |
if (tokens == null) | |
return null; | |
StringBuilder sb = new StringBuilder(); | |
for (int i = 0; i < tokens.length; i++) { | |
if (i > 0) | |
sb.append(separator); | |
sb.append(tokens[i]); | |
} | |
return sb.toString(); | |
} | |
/** | |
* Join the specified tokens into a delimited string. | |
* | |
* @param tokens The tokens to join. | |
* @param d The delimiter. | |
* @return The delimited string. If <code>tokens</code> is <jk>null</jk>, returns <jk>null</jk>. | |
*/ | |
public static String join(int[] tokens, String d) { | |
if (tokens == null) | |
return null; | |
StringBuilder sb = new StringBuilder(); | |
for (int i = 0; i < tokens.length; i++) { | |
if (i > 0) | |
sb.append(d); | |
sb.append(tokens[i]); | |
} | |
return sb.toString(); | |
} | |
/** | |
* Join the specified tokens into a delimited string. | |
* | |
* @param tokens The tokens to join. | |
* @param d The delimiter. | |
* @return The delimited string. If <code>tokens</code> is <jk>null</jk>, returns <jk>null</jk>. | |
*/ | |
public static String join(Collection<?> tokens, String d) { | |
if (tokens == null) | |
return null; | |
return join(tokens, d, new StringBuilder()).toString(); | |
} | |
/** | |
* Joins the specified tokens into a delimited string and writes the output to the specified string builder. | |
* | |
* @param tokens The tokens to join. | |
* @param d The delimiter. | |
* @param sb The string builder to append the response to. | |
* @return The same string builder passed in as <code>sb</code>. | |
*/ | |
public static StringBuilder join(Collection<?> tokens, String d, StringBuilder sb) { | |
if (tokens == null) | |
return sb; | |
for (Iterator<?> iter = tokens.iterator(); iter.hasNext();) { | |
sb.append(iter.next()); | |
if (iter.hasNext()) | |
sb.append(d); | |
} | |
return sb; | |
} | |
/** | |
* Joins the specified tokens into a delimited string. | |
* | |
* @param tokens The tokens to join. | |
* @param d The delimiter. | |
* @return The delimited string. If <code>tokens</code> is <jk>null</jk>, returns <jk>null</jk>. | |
*/ | |
public static String join(Object[] tokens, char d) { | |
if (tokens == null) | |
return null; | |
return join(tokens, d, new StringBuilder()).toString(); | |
} | |
/** | |
* Join the specified tokens into a delimited string and writes the output to the specified string builder. | |
* | |
* @param tokens The tokens to join. | |
* @param d The delimiter. | |
* @param sb The string builder to append the response to. | |
* @return The same string builder passed in as <code>sb</code>. | |
*/ | |
public static StringBuilder join(Object[] tokens, char d, StringBuilder sb) { | |
if (tokens == null) | |
return sb; | |
for (int i = 0; i < tokens.length; i++) { | |
if (i > 0) | |
sb.append(d); | |
sb.append(tokens[i]); | |
} | |
return sb; | |
} | |
/** | |
* Join the specified tokens into a delimited string. | |
* | |
* @param tokens The tokens to join. | |
* @param d The delimiter. | |
* @return The delimited string. If <code>tokens</code> is <jk>null</jk>, returns <jk>null</jk>. | |
*/ | |
public static String join(int[] tokens, char d) { | |
if (tokens == null) | |
return null; | |
StringBuilder sb = new StringBuilder(); | |
for (int i = 0; i < tokens.length; i++) { | |
if (i > 0) | |
sb.append(d); | |
sb.append(tokens[i]); | |
} | |
return sb.toString(); | |
} | |
/** | |
* Join the specified tokens into a delimited string. | |
* | |
* @param tokens The tokens to join. | |
* @param d The delimiter. | |
* @return The delimited string. If <code>tokens</code> is <jk>null</jk>, returns <jk>null</jk>. | |
*/ | |
public static String join(Collection<?> tokens, char d) { | |
if (tokens == null) | |
return null; | |
StringBuilder sb = new StringBuilder(); | |
for (Iterator<?> iter = tokens.iterator(); iter.hasNext();) { | |
sb.append(iter.next()); | |
if (iter.hasNext()) | |
sb.append(d); | |
} | |
return sb.toString(); | |
} | |
/** | |
* Shortcut for calling <code>split(s, <js>','</js>)</code> | |
* | |
* @param s The string to split. Can be <jk>null</jk>. | |
* @return The tokens, or <jk>null</jk> if the string was null. | |
*/ | |
public static String[] split(String s) { | |
return split(s, ','); | |
} | |
/** | |
* Splits a character-delimited string into a string array. | |
* | |
* <p> | |
* Does not split on escaped-delimiters (e.g. "\,"); | |
* Resulting tokens are trimmed of whitespace. | |
* | |
* <p> | |
* <b>NOTE:</b> This behavior is different than the Jakarta equivalent. | |
* split("a,b,c",',') -> {"a","b","c"} | |
* split("a, b ,c ",',') -> {"a","b","c"} | |
* split("a,,c",',') -> {"a","","c"} | |
* split(",,",',') -> {"","",""} | |
* split("",',') -> {} | |
* split(null,',') -> null | |
* split("a,b\,c,d", ',', false) -> {"a","b\,c","d"} | |
* split("a,b\\,c,d", ',', false) -> {"a","b\","c","d"} | |
* split("a,b\,c,d", ',', true) -> {"a","b,c","d"} | |
* | |
* @param s The string to split. Can be <jk>null</jk>. | |
* @param c The character to split on. | |
* @return The tokens, or <jk>null</jk> if the string was null. | |
*/ | |
public static String[] split(String s, char c) { | |
return split(s, c, Integer.MAX_VALUE); | |
} | |
/** | |
* Same as {@link #split(String, char)} but limits the number of tokens returned. | |
* | |
* @param s The string to split. Can be <jk>null</jk>. | |
* @param c The character to split on. | |
* @param limit The maximum number of tokens to return. | |
* @return The tokens, or <jk>null</jk> if the string was null. | |
*/ | |
public static String[] split(String s, char c, int limit) { | |
char[] unEscapeChars = new char[]{'\\', c}; | |
if (s == null) | |
return null; | |
if (isEmpty(s)) | |
return new String[0]; | |
if (s.indexOf(c) == -1) | |
return new String[]{s}; | |
List<String> l = new LinkedList<>(); | |
char[] sArray = s.toCharArray(); | |
int x1 = 0, escapeCount = 0; | |
limit--; | |
for (int i = 0; i < sArray.length && limit > 0; i++) { | |
if (sArray[i] == '\\') escapeCount++; | |
else if (sArray[i]==c && escapeCount % 2 == 0) { | |
String s2 = new String(sArray, x1, i-x1); | |
String s3 = unEscapeChars(s2, unEscapeChars); | |
l.add(s3.trim()); | |
limit--; | |
x1 = i+1; | |
} | |
if (sArray[i] != '\\') escapeCount = 0; | |
} | |
String s2 = new String(sArray, x1, sArray.length-x1); | |
String s3 = unEscapeChars(s2, unEscapeChars); | |
l.add(s3.trim()); | |
return l.toArray(new String[l.size()]); | |
} | |
/** | |
* Same as {@link #split(String, char)} except splits all strings in the input and returns a single result. | |
* | |
* @param s The string to split. Can be <jk>null</jk>. | |
* @param c The character to split on. | |
* @return The tokens. | |
*/ | |
public static String[] split(String[] s, char c) { | |
if (s == null) | |
return null; | |
List<String> l = new LinkedList<>(); | |
for (String ss : s) { | |
if (ss == null || ss.indexOf(c) == -1) | |
l.add(ss); | |
else | |
l.addAll(Arrays.asList(split(ss, c))); | |
} | |
return l.toArray(new String[l.size()]); | |
} | |
/** | |
* Splits a list of key-value pairs into an ordered map. | |
* | |
* <p> | |
* Example: | |
* <p class='bcode'> | |
* String in = <js>"foo=1;bar=2"</js>; | |
* Map m = StringUtils.<jsm>splitMap</jsm>(in, <js>';'</js>, <js>'='</js>, <jk>true</jk>); | |
* </p> | |
* | |
* @param s The string to split. | |
* @param delim The delimiter between the key-value pairs. | |
* @param eq The delimiter between the key and value. | |
* @param trim Trim strings after parsing. | |
* @return The parsed map. Never <jk>null</jk>. | |
*/ | |
public static Map<String,String> splitMap(String s, char delim, char eq, boolean trim) { | |
char[] unEscapeChars = new char[]{'\\', delim, eq}; | |
if (s == null) | |
return null; | |
if (isEmpty(s)) | |
return Collections.EMPTY_MAP; | |
Map<String,String> m = new LinkedHashMap<>(); | |
int | |
S1 = 1, // Found start of key, looking for equals. | |
S2 = 2; // Found equals, looking for delimiter (or end). | |
int state = S1; | |
char[] sArray = s.toCharArray(); | |
int x1 = 0, escapeCount = 0; | |
String key = null; | |
for (int i = 0; i < sArray.length + 1; i++) { | |
char c = i == sArray.length ? delim : sArray[i]; | |
if (c == '\\') | |
escapeCount++; | |
if (escapeCount % 2 == 0) { | |
if (state == S1) { | |
if (c == eq) { | |
key = s.substring(x1, i); | |
if (trim) | |
key = trim(key); | |
key = unEscapeChars(key, unEscapeChars); | |
state = S2; | |
x1 = i+1; | |
} else if (c == delim) { | |
key = s.substring(x1, i); | |
if (trim) | |
key = trim(key); | |
key = unEscapeChars(key, unEscapeChars); | |
m.put(key, ""); | |
state = S1; | |
x1 = i+1; | |
} | |
} else if (state == S2) { | |
if (c == delim) { | |
String val = s.substring(x1, i); | |
if (trim) | |
val = trim(val); | |
val = unEscapeChars(val, unEscapeChars); | |
m.put(key, val); | |
key = null; | |
x1 = i+1; | |
state = S1; | |
} | |
} | |
} | |
if (c != '\\') escapeCount = 0; | |
} | |
return m; | |
} | |
/** | |
* Returns <jk>true</jk> if the specified string contains any of the specified characters. | |
* | |
* @param s The string to test. | |
* @param chars The characters to look for. | |
* @return | |
* <jk>true</jk> if the specified string contains any of the specified characters. | |
* <br><jk>false</jk> if the string is <jk>null</jk>. | |
*/ | |
public static boolean containsAny(String s, char...chars) { | |
if (s == null) | |
return false; | |
for (int i = 0; i < s.length(); i++) { | |
char c = s.charAt(i); | |
for (char c2 : chars) | |
if (c == c2) | |
return true; | |
} | |
return false; | |
} | |
/** | |
* Splits a space-delimited string with optionally quoted arguments. | |
* | |
* <p> | |
* Examples: | |
* <ul> | |
* <li><js>"foo"</js> => <code>["foo"]</code> | |
* <li><js>" foo "</js> => <code>["foo"]</code> | |
* <li><js>"foo bar baz"</js> => <code>["foo","bar","baz"]</code> | |
* <li><js>"foo 'bar baz'"</js> => <code>["foo","bar baz"]</code> | |
* <li><js>"foo \"bar baz\""</js> => <code>["foo","bar baz"]</code> | |
* <li><js>"foo 'bar\'baz'"</js> => <code>["foo","bar'baz"]</code> | |
* </ul> | |
* | |
* @param s The input string. | |
* @return | |
* The results, or <jk>null</jk> if the input was <jk>null</jk>. | |
* <br>An empty string results in an empty array. | |
*/ | |
public static String[] splitQuoted(String s) { | |
char[] unEscapeChars = new char[]{'\\', '\'', '"'}; | |
if (s == null) | |
return null; | |
s = s.trim(); | |
if (isEmpty(s)) | |
return new String[0]; | |
if (! containsAny(s, ' ', '\t', '\'', '"')) | |
return new String[]{s}; | |
int | |
S1 = 1, // Looking for start of token. | |
S2 = 2, // Found ', looking for end ' | |
S3 = 3, // Found ", looking for end " | |
S4 = 4; // Found non-whitespace, looking for end whitespace. | |
int state = S1; | |
boolean isInEscape = false, needsUnescape = false; | |
int mark = 0; | |
List<String> l = new ArrayList<>(); | |
for (int i = 0; i < s.length(); i++) { | |
char c = s.charAt(i); | |
if (state == S1) { | |
if (c == '\'') { | |
state = S2; | |
mark = i+1; | |
} else if (c == '"') { | |
state = S3; | |
mark = i+1; | |
} else if (c != ' ' && c != '\t') { | |
state = S4; | |
mark = i; | |
} | |
} else if (state == S2 || state == S3) { | |
if (c == '\\') { | |
isInEscape = ! isInEscape; | |
needsUnescape = true; | |
} else if (! isInEscape) { | |
if (c == (state == S2 ? '\'' : '"')) { | |
String s2 = s.substring(mark, i); | |
if (needsUnescape) | |
s2 = unEscapeChars(s2, unEscapeChars, '\\'); | |
l.add(s2); | |
state = S1; | |
isInEscape = needsUnescape = false; | |
} | |
} else { | |
isInEscape = false; | |
} | |
} else if (state == S4) { | |
if (c == ' ' || c == '\t') { | |
l.add(s.substring(mark, i)); | |
state = S1; | |
} | |
} | |
} | |
if (state == S4) | |
l.add(s.substring(mark)); | |
else if (state == S2 || state == S3) | |
throw new RuntimeException("Unmatched string quotes: " + s); | |
return l.toArray(new String[l.size()]); | |
} | |
/** | |
* Returns <jk>true</jk> if specified string is <jk>null</jk> or empty. | |
* | |
* @param s The string to check. | |
* @return <jk>true</jk> if specified string is <jk>null</jk> or empty. | |
*/ | |
public static boolean isEmpty(String s) { | |
return s == null || s.isEmpty(); | |
} | |
/** | |
* Returns <jk>true</jk> if specified string is <jk>null</jk> or it's {@link #toString()} method returns an empty | |
* string. | |
* | |
* @param s The string to check. | |
* @return | |
* <jk>true</jk> if specified string is <jk>null</jk> or it's {@link #toString()} method returns an empty string. | |
*/ | |
public static boolean isEmpty(Object s) { | |
return s == null || s.toString().isEmpty(); | |
} | |
/** | |
* Returns <jk>null</jk> if the specified string is <jk>null</jk> or empty. | |
* | |
* @param s The string to check. | |
* @return <jk>null</jk> if the specified string is <jk>null</jk> or empty, or the same string if not. | |
*/ | |
public static String nullIfEmpty(String s) { | |
if (s == null || s.isEmpty()) | |
return null; | |
return s; | |
} | |
/** | |
* Returns an empty string if the specified string is <jk>null</jk>. | |
* | |
* @param s The string to check. | |
* @return An empty string if the specified string is <jk>null</jk>, or the same string otherwise. | |
*/ | |
public static String emptyIfNull(String s) { | |
if (s == null) | |
return ""; | |
return s; | |
} | |
/** | |
* Removes escape characters (\) from the specified characters. | |
* | |
* @param s The string to remove escape characters from. | |
* @param toEscape The characters escaped. | |
* @return A new string if characters were removed, or the same string if not or if the input was <jk>null</jk>. | |
*/ | |
public static String unEscapeChars(String s, char[] toEscape) { | |
return unEscapeChars(s, toEscape, '\\'); | |
} | |
/** | |
* Removes escape characters (specified by escapeChar) from the specified characters. | |
* | |
* @param s The string to remove escape characters from. | |
* @param toEscape The characters escaped. | |
* @param escapeChar The escape character. | |
* @return A new string if characters were removed, or the same string if not or if the input was <jk>null</jk>. | |
*/ | |
public static String unEscapeChars(String s, char[] toEscape, char escapeChar) { | |
if (s == null) return null; | |
if (s.length() == 0 || toEscape == null || toEscape.length == 0 || escapeChar == 0) return s; | |
StringBuffer sb = new StringBuffer(s.length()); | |
char[] sArray = s.toCharArray(); | |
for (int i = 0; i < sArray.length; i++) { | |
char c = sArray[i]; | |
if (c == escapeChar) { | |
if (i+1 != sArray.length) { | |
char c2 = sArray[i+1]; | |
boolean isOneOf = false; | |
for (int j = 0; j < toEscape.length && ! isOneOf; j++) | |
isOneOf = (c2 == toEscape[j]); | |
if (isOneOf) { | |
i++; | |
} else if (c2 == escapeChar) { | |
sb.append(escapeChar); | |
i++; | |
} | |
} | |
} | |
sb.append(sArray[i]); | |
} | |
return sb.toString(); | |
} | |
/** | |
* Debug method for rendering non-ASCII character sequences. | |
* | |
* @param s The string to decode. | |
* @return A string with non-ASCII characters converted to <js>"[hex]"</js> sequences. | |
*/ | |
public static String decodeHex(String s) { | |
if (s == null) | |
return null; | |
StringBuilder sb = new StringBuilder(); | |
for (char c : s.toCharArray()) { | |
if (c < ' ' || c > '~') | |
sb.append("["+Integer.toHexString(c)+"]"); | |
else | |
sb.append(c); | |
} | |
return sb.toString(); | |
} | |
/** | |
* An efficient method for checking if a string starts with a character. | |
* | |
* @param s The string to check. Can be <jk>null</jk>. | |
* @param c The character to check for. | |
* @return <jk>true</jk> if the specified string is not <jk>null</jk> and starts with the specified character. | |
*/ | |
public static boolean startsWith(String s, char c) { | |
if (s != null) { | |
int i = s.length(); | |
if (i > 0) | |
return s.charAt(0) == c; | |
} | |
return false; | |
} | |
/** | |
* An efficient method for checking if a string ends with a character. | |
* | |
* @param s The string to check. Can be <jk>null</jk>. | |
* @param c The character to check for. | |
* @return <jk>true</jk> if the specified string is not <jk>null</jk> and ends with the specified character. | |
*/ | |
public static boolean endsWith(String s, char c) { | |
if (s != null) { | |
int i = s.length(); | |
if (i > 0) | |
return s.charAt(i-1) == c; | |
} | |
return false; | |
} | |
/** | |
* Same as {@link #endsWith(String, char)} except check for multiple characters. | |
* | |
* @param s The string to check. Can be <jk>null</jk>. | |
* @param c The characters to check for. | |
* @return <jk>true</jk> if the specified string is not <jk>null</jk> and ends with the specified character. | |
*/ | |
public static boolean endsWith(String s, char...c) { | |
if (s != null) { | |
int i = s.length(); | |
if (i > 0) { | |
char c2 = s.charAt(i-1); | |
for (char cc : c) | |
if (c2 == cc) | |
return true; | |
} | |
} | |
return false; | |
} | |
/** | |
* Converts the specified number into a 4 hexadecimal characters. | |
* | |
* @param num The number to convert to hex. | |
* @return A <code><jk>char</jk>[4]</code> containing the specified characters. | |
*/ | |
public static final char[] toHex(int num) { | |
char[] n = new char[4]; | |
int a = num%16; | |
n[3] = (char)(a > 9 ? 'A'+a-10 : '0'+a); | |
int base = 16; | |
for (int i = 1; i < 4; i++) { | |
a = (num/base)%16; | |
base <<= 4; | |
n[3-i] = (char)(a > 9 ? 'A'+a-10 : '0'+a); | |
} | |
return n; | |
} | |
/** | |
* Tests two strings for equality, but gracefully handles nulls. | |
* | |
* @param s1 String 1. | |
* @param s2 String 2. | |
* @return <jk>true</jk> if the strings are equal. | |
*/ | |
public static boolean isEquals(String s1, String s2) { | |
if (s1 == null) | |
return s2 == null; | |
if (s2 == null) | |
return false; | |
return s1.equals(s2); | |
} | |
/** | |
* Shortcut for calling <code>base64Encode(in.getBytes(<js>"UTF-8"</js>))</code> | |
* | |
* @param in The input string to convert. | |
* @return The string converted to BASE-64 encoding. | |
*/ | |
public static String base64EncodeToString(String in) { | |
if (in == null) | |
return null; | |
return base64Encode(in.getBytes(IOUtils.UTF8)); | |
} | |
/** | |
* BASE64-encodes the specified byte array. | |
* | |
* @param in The input byte array to convert. | |
* @return The byte array converted to a BASE-64 encoded string. | |
*/ | |
public static String base64Encode(byte[] in) { | |
int outLength = (in.length * 4 + 2) / 3; // Output length without padding | |
char[] out = new char[((in.length + 2) / 3) * 4]; // Length includes padding. | |
int iIn = 0; | |
int iOut = 0; | |
while (iIn < in.length) { | |
int i0 = in[iIn++] & 0xff; | |
int i1 = iIn < in.length ? in[iIn++] & 0xff : 0; | |
int i2 = iIn < in.length ? in[iIn++] & 0xff : 0; | |
int o0 = i0 >>> 2; | |
int o1 = ((i0 & 3) << 4) | (i1 >>> 4); | |
int o2 = ((i1 & 0xf) << 2) | (i2 >>> 6); | |
int o3 = i2 & 0x3F; | |
out[iOut++] = base64m1[o0]; | |
out[iOut++] = base64m1[o1]; | |
out[iOut] = iOut < outLength ? base64m1[o2] : '='; | |
iOut++; | |
out[iOut] = iOut < outLength ? base64m1[o3] : '='; | |
iOut++; | |
} | |
return new String(out); | |
} | |
/** | |
* Shortcut for calling <code>base64Decode(String)</code> and converting the result to a UTF-8 encoded string. | |
* | |
* @param in The BASE-64 encoded string to decode. | |
* @return The decoded string. | |
*/ | |
public static String base64DecodeToString(String in) { | |
byte[] b = base64Decode(in); | |
if (b == null) | |
return null; | |
return new String(b, IOUtils.UTF8); | |
} | |
/** | |
* BASE64-decodes the specified string. | |
* | |
* @param in The BASE-64 encoded string. | |
* @return The decoded byte array. | |
*/ | |
public static byte[] base64Decode(String in) { | |
if (in == null) | |
return null; | |
byte bIn[] = in.getBytes(IOUtils.UTF8); | |
if (bIn.length % 4 != 0) | |
illegalArg("Invalid BASE64 string length. Must be multiple of 4."); | |
// Strip out any trailing '=' filler characters. | |
int inLength = bIn.length; | |
while (inLength > 0 && bIn[inLength - 1] == '=') | |
inLength--; | |
int outLength = (inLength * 3) / 4; | |
byte[] out = new byte[outLength]; | |
int iIn = 0; | |
int iOut = 0; | |
while (iIn < inLength) { | |
int i0 = bIn[iIn++]; | |
int i1 = bIn[iIn++]; | |
int i2 = iIn < inLength ? bIn[iIn++] : 'A'; | |
int i3 = iIn < inLength ? bIn[iIn++] : 'A'; | |
int b0 = base64m2[i0]; | |
int b1 = base64m2[i1]; | |
int b2 = base64m2[i2]; | |
int b3 = base64m2[i3]; | |
int o0 = (b0 << 2) | (b1 >>> 4); | |
int o1 = ((b1 & 0xf) << 4) | (b2 >>> 2); | |
int o2 = ((b2 & 3) << 6) | b3; | |
out[iOut++] = (byte)o0; | |
if (iOut < outLength) | |
out[iOut++] = (byte)o1; | |
if (iOut < outLength) | |
out[iOut++] = (byte)o2; | |
} | |
return out; | |
} | |
/** | |
* Generated a random UUID with the specified number of characters. | |
* | |
* <p> | |
* Characters are composed of lower-case ASCII letters and numbers only. | |
* | |
* <p> | |
* This method conforms to the restrictions for hostnames as specified in <a class="doclink" href="https://tools.ietf.org/html/rfc952">RFC 952</a> | |
* Since each character has 36 possible values, the square approximation formula for the number of generated IDs | |
* that would produce a 50% chance of collision is: | |
* <code>sqrt(36^N)</code>. | |
* Dividing this number by 10 gives you an approximation of the number of generated IDs needed to produce a | |
* <1% chance of collision. | |
* | |
* <p> | |
* For example, given 5 characters, the number of generated IDs need to produce a <1% chance of collision would | |
* be: | |
* <code>sqrt(36^5)/10=777</code> | |
* | |
* @param numchars The number of characters in the generated UUID. | |
* @return A new random UUID. | |
*/ | |
public static String generateUUID(int numchars) { | |
Random r = new Random(); | |
StringBuilder sb = new StringBuilder(numchars); | |
for (int i = 0; i < numchars; i++) { | |
int c = r.nextInt(36) + 97; | |
if (c > 'z') | |
c -= ('z'-'0'+1); | |
sb.append((char)c); | |
} | |
return sb.toString(); | |
} | |
/** | |
* Same as {@link String#trim()} but prevents <code>NullPointerExceptions</code>. | |
* | |
* @param s The string to trim. | |
* @return The trimmed string, or <jk>null</jk> if the string was <jk>null</jk>. | |
*/ | |
public static String trim(String s) { | |
if (s == null) | |
return null; | |
return s.trim(); | |
} | |
/** | |
* Parses an ISO8601 string into a date. | |
* | |
* @param date The date string. | |
* @return The parsed date. | |
* @throws IllegalArgumentException | |
*/ | |
public static Date parseISO8601Date(String date) throws IllegalArgumentException { | |
if (isEmpty(date)) | |
return null; | |
date = date.trim().replace(' ', 'T'); // Convert to 'standard' ISO8601 | |
if (date.indexOf(',') != -1) // Trim milliseconds | |
date = date.substring(0, date.indexOf(',')); | |
if (date.matches("\\d{4}")) | |
date += "-01-01T00:00:00"; | |
else if (date.matches("\\d{4}\\-\\d{2}")) | |
date += "-01T00:00:00"; | |
else if (date.matches("\\d{4}\\-\\d{2}\\-\\d{2}")) | |
date += "T00:00:00"; | |
else if (date.matches("\\d{4}\\-\\d{2}\\-\\d{2}T\\d{2}")) | |
date += ":00:00"; | |
else if (date.matches("\\d{4}\\-\\d{2}\\-\\d{2}T\\d{2}\\:\\d{2}")) | |
date += ":00"; | |
return DatatypeConverter.parseDateTime(date).getTime(); | |
} | |
/** | |
* Simple utility for replacing variables of the form <js>"{key}"</js> with values in the specified map. | |
* | |
* <p> | |
* Nested variables are supported in both the input string and map values. | |
* | |
* <p> | |
* If the map does not contain the specified value, the variable is not replaced. | |
* | |
* <p> | |
* <jk>null</jk> values in the map are treated as blank strings. | |
* | |
* @param s The string containing variables to replace. | |
* @param m The map containing the variable values. | |
* @return The new string with variables replaced, or the original string if it didn't have variables in it. | |
*/ | |
public static String replaceVars(String s, Map<String,Object> m) { | |
if (s == null) | |
return null; | |
if (s.indexOf('{') == -1) | |
return s; | |
int S1 = 1; // Not in variable, looking for { | |
int S2 = 2; // Found {, Looking for } | |
int state = S1; | |
boolean hasInternalVar = false; | |
int x = 0; | |
int depth = 0; | |
int length = s.length(); | |
StringBuilder out = new StringBuilder(); | |
for (int i = 0; i < length; i++) { | |
char c = s.charAt(i); | |
if (state == S1) { | |
if (c == '{') { | |
state = S2; | |
x = i; | |
} else { | |
out.append(c); | |
} | |
} else /* state == S2 */ { | |
if (c == '{') { | |
depth++; | |
hasInternalVar = true; | |
} else if (c == '}') { | |
if (depth > 0) { | |
depth--; | |
} else { | |
String key = s.substring(x+1, i); | |
key = (hasInternalVar ? replaceVars(key, m) : key); | |
hasInternalVar = false; | |
if (! m.containsKey(key)) | |
out.append('{').append(key).append('}'); | |
else { | |
Object val = m.get(key); | |
if (val == null) | |
val = ""; | |
String v = val.toString(); | |
// If the replacement also contains variables, replace them now. | |
if (v.indexOf('{') != -1) | |
v = replaceVars(v, m); | |
out.append(v); | |
} | |
state = 1; | |
} | |
} | |
} | |
} | |
return out.toString(); | |
} | |
/** | |
* Returns <jk>true</jk> if the specified path string is prefixed with the specified prefix. | |
* | |
* <h5 class='section'>Example:</h5> | |
* <p class='bcode'> | |
* pathStartsWith(<js>"foo"</js>, <js>"foo"</js>); <jc>// true</jc> | |
* pathStartsWith(<js>"foo/bar"</js>, <js>"foo"</js>); <jc>// true</jc> | |
* pathStartsWith(<js>"foo2"</js>, <js>"foo"</js>); <jc>// false</jc> | |
* pathStartsWith(<js>"foo2"</js>, <js>""</js>); <jc>// false</jc> | |
* </p> | |
* | |
* @param path The path to check. | |
* @param pathPrefix The prefix. | |
* @return <jk>true</jk> if the specified path string is prefixed with the specified prefix. | |
*/ | |
public static boolean pathStartsWith(String path, String pathPrefix) { | |
if (path == null || pathPrefix == null) | |
return false; | |
if (path.startsWith(pathPrefix)) | |
return path.length() == pathPrefix.length() || path.charAt(pathPrefix.length()) == '/'; | |
return false; | |
} | |
/** | |
* Same as {@link #pathStartsWith(String, String)} but returns <jk>true</jk> if at least one prefix matches. | |
* | |
* @param path The path to check. | |
* @param pathPrefixes The prefixes. | |
* @return <jk>true</jk> if the specified path string is prefixed with any of the specified prefixes. | |
*/ | |
public static boolean pathStartsWith(String path, String[] pathPrefixes) { | |
for (String p : pathPrefixes) | |
if (pathStartsWith(path, p)) | |
return true; | |
return false; | |
} | |
/** | |
* Replaces <js>"\\uXXXX"</js> character sequences with their unicode characters. | |
* | |
* @param s The string to replace unicode sequences in. | |
* @return A string with unicode sequences replaced. | |
*/ | |
public static String replaceUnicodeSequences(String s) { | |
if (s.indexOf('\\') == -1) | |
return s; | |
Pattern p = Pattern.compile("\\\\u(\\p{XDigit}{4})"); | |
Matcher m = p.matcher(s); | |
StringBuffer sb = new StringBuffer(s.length()); | |
while (m.find()) { | |
String ch = String.valueOf((char) Integer.parseInt(m.group(1), 16)); | |
m.appendReplacement(sb, Matcher.quoteReplacement(ch)); | |
} | |
m.appendTail(sb); | |
return sb.toString(); | |
} | |
/** | |
* Creates an escaped-unicode sequence (e.g. <js>"\\u1234"</js>) for the specified character. | |
* | |
* @param c The character to create a sequence for. | |
* @return An escaped-unicode sequence. | |
*/ | |
public static String unicodeSequence(char c) { | |
StringBuilder sb = new StringBuilder(6); | |
sb.append('\\').append('u'); | |
for (char cc : toHex(c)) | |
sb.append(cc); | |
return sb.toString(); | |
} | |
/** | |
* Returns the specified field in a delimited string without splitting the string. | |
* | |
* <p> | |
* Equivalent to the following: | |
* <p class='bcode'> | |
* String in = <js>"0,1,2"</js>; | |
* String[] parts = in.split(<js>","</js>); | |
* String p1 = (parts.<jk>length</jk> > 1 ? parts[1] : <js>""</js>); | |
* </p> | |
* | |
* @param fieldNum The field number. Zero-indexed. | |
* @param s The input string. | |
* @param delim The delimiter character. | |
* @return The field entry in the string, or a blank string if it doesn't exist or the string is null. | |
*/ | |
public static String getField(int fieldNum, String s, char delim) { | |
return getField(fieldNum, s, delim, ""); | |
} | |
/** | |
* Same as {@link #getField(int, String, char)} except allows you to specify the default value. | |
* | |
* @param fieldNum The field number. Zero-indexed. | |
* @param s The input string. | |
* @param delim The delimiter character. | |
* @param def The default value if the field does not exist. | |
* @return The field entry in the string, or the default value if it doesn't exist or the string is null. | |
*/ | |
public static String getField(int fieldNum, String s, char delim, String def) { | |
if (s == null || fieldNum < 0) | |
return def; | |
int start = 0; | |
for (int i = 0; i < s.length(); i++) { | |
char c = s.charAt(i); | |
if (c == delim) { | |
fieldNum--; | |
if (fieldNum == 0) | |
start = i+1; | |
} | |
if (fieldNum < 0) | |
return s.substring(start, i); | |
} | |
if (start == 0) | |
return def; | |
return s.substring(start); | |
} | |
/** | |
* Calls {@link #toString()} on the specified object if it's not null. | |
* | |
* @param o The object to convert to a string. | |
* @return The object converted to a string, or <jk>null</jk> if the object was null. | |
*/ | |
public static String asString(Object o) { | |
return (o == null ? null : o.toString()); | |
} | |
/** | |
* Converts an array of objects to an array of strings. | |
* | |
* @param o The array of objects to convert to strings. | |
* @return A new array of objects converted to strings. | |
*/ | |
public static String[] asStrings(Object...o) { | |
if (o == null) | |
return null; | |
if (o instanceof String[]) | |
return (String[])o; | |
String[] s = new String[o.length]; | |
for (int i = 0; i < o.length; i++) | |
s[i] = asString(o[i]); | |
return s; | |
} | |
/** | |
* Converts a hexadecimal byte stream (e.g. "34A5BC") into a UTF-8 encoded string. | |
* | |
* @param hex The hexadecimal string. | |
* @return The UTF-8 string. | |
*/ | |
public static String fromHexToUTF8(String hex) { | |
ByteBuffer buff = ByteBuffer.allocate(hex.length()/2); | |
for (int i = 0; i < hex.length(); i+=2) | |
buff.put((byte)Integer.parseInt(hex.substring(i, i+2), 16)); | |
buff.rewind(); | |
Charset cs = Charset.forName("UTF-8"); | |
return cs.decode(buff).toString(); | |
} | |
/** | |
* Converts a space-deliminted hexadecimal byte stream (e.g. "34 A5 BC") into a UTF-8 encoded string. | |
* | |
* @param hex The hexadecimal string. | |
* @return The UTF-8 string. | |
*/ | |
public static String fromSpacedHexToUTF8(String hex) { | |
ByteBuffer buff = ByteBuffer.allocate((hex.length()+1)/3); | |
for (int i = 0; i < hex.length(); i+=3) | |
buff.put((byte)Integer.parseInt(hex.substring(i, i+2), 16)); | |
buff.rewind(); | |
Charset cs = Charset.forName("UTF-8"); | |
return cs.decode(buff).toString(); | |
} | |
private static final char[] HEX = "0123456789ABCDEF".toCharArray(); | |
/** | |
* Converts a byte array into a simple hexadecimal character string. | |
* | |
* @param bytes The bytes to convert to hexadecimal. | |
* @return A new string consisting of hexadecimal characters. | |
*/ | |
public static String toHex(byte[] bytes) { | |
StringBuilder sb = new StringBuilder(bytes.length * 2); | |
for (int j = 0; j < bytes.length; j++) { | |
int v = bytes[j] & 0xFF; | |
sb.append(HEX[v >>> 4]).append(HEX[v & 0x0F]); | |
} | |
return sb.toString(); | |
} | |
/** | |
* Same as {@link #toHex(byte[])} but puts spaces between the byte strings. | |
* | |
* @param bytes The bytes to convert to hexadecimal. | |
* @return A new string consisting of hexadecimal characters. | |
*/ | |
public static String toSpacedHex(byte[] bytes) { | |
StringBuilder sb = new StringBuilder(bytes.length * 3); | |
for (int j = 0; j < bytes.length; j++) { | |
if (j > 0) | |
sb.append(' '); | |
int v = bytes[j] & 0xFF; | |
sb.append(HEX[v >>> 4]).append(HEX[v & 0x0F]); | |
} | |
return sb.toString(); | |
} | |
/** | |
* Converts a hexadecimal character string to a byte array. | |
* | |
* @param hex The string to convert to a byte array. | |
* @return A new byte array. | |
*/ | |
public static byte[] fromHex(String hex) { | |
ByteBuffer buff = ByteBuffer.allocate(hex.length()/2); | |
for (int i = 0; i < hex.length(); i+=2) | |
buff.put((byte)Integer.parseInt(hex.substring(i, i+2), 16)); | |
buff.rewind(); | |
return buff.array(); | |
} | |
/** | |
* Same as {@link #fromHex(String)} except expects spaces between the byte strings. | |
* | |
* @param hex The string to convert to a byte array. | |
* @return A new byte array. | |
*/ | |
public static byte[] fromSpacedHex(String hex) { | |
ByteBuffer buff = ByteBuffer.allocate((hex.length()+1)/3); | |
for (int i = 0; i < hex.length(); i+=3) | |
buff.put((byte)Integer.parseInt(hex.substring(i, i+2), 16)); | |
buff.rewind(); | |
return buff.array(); | |
} | |
/** | |
* Creates a repeated pattern. | |
* | |
* @param count The number of times to repeat the pattern. | |
* @param pattern The pattern to repeat. | |
* @return A new string consisting of the repeated pattern. | |
*/ | |
public static String repeat(int count, String pattern) { | |
StringBuilder sb = new StringBuilder(pattern.length() * count); | |
for (int i = 0; i < count; i++) | |
sb.append(pattern); | |
return sb.toString(); | |
} | |
/** | |
* Trims whitespace characters from the beginning of the specified string. | |
* | |
* @param s The string to trim. | |
* @return The trimmed string, or <jk>null</jk> if the string was <jk>null</jk>. | |
*/ | |
public static String trimStart(String s) { | |
if (s != null) | |
while (s.length() > 0 && Character.isWhitespace(s.charAt(0))) | |
s = s.substring(1); | |
return s; | |
} | |
/** | |
* Trims whitespace characters from the end of the specified string. | |
* | |
* @param s The string to trim. | |
* @return The trimmed string, or <jk>null</jk> if the string was <jk>null</jk>. | |
*/ | |
public static String trimEnd(String s) { | |
if (s != null) | |
while (s.length() > 0 && Character.isWhitespace(s.charAt(s.length()-1))) | |
s = s.substring(0, s.length()-1); | |
return s; | |
} | |
/** | |
* Returns <jk>true</jk> if the specified string is one of the specified values. | |
* | |
* @param s | |
* The string to test. | |
* Can be <jk>null</jk>. | |
* @param values | |
* The values to test. | |
* Can contain <jk>null</jk>. | |
* @return <jk>true</jk> if the specified string is one of the specified values. | |
*/ | |
public static boolean isOneOf(String s, String...values) { | |
for (int i = 0; i < values.length; i++) | |
if (StringUtils.isEquals(s, values[i])) | |
return true; | |
return false; | |
} | |
/** | |
* Trims <js>'/'</js> characters from both the start and end of the specified string. | |
* | |
* @param s The string to trim. | |
* @return A new trimmed string, or the same string if no trimming was necessary. | |
*/ | |
public static String trimSlashes(String s) { | |
if (s == null) | |
return null; | |
while (endsWith(s, '/')) | |
s = s.substring(0, s.length()-1); | |
while (s.length() > 0 && s.charAt(0) == '/') | |
s = s.substring(1); | |
return s; | |
} | |
/** | |
* Trims <js>'/'</js> characters from the end of the specified string. | |
* | |
* @param s The string to trim. | |
* @return A new trimmed string, or the same string if no trimming was necessary. | |
*/ | |
public static String trimTrailingSlashes(String s) { | |
if (s == null) | |
return null; | |
while (endsWith(s, '/')) | |
s = s.substring(0, s.length()-1); | |
return s; | |
} | |
/** | |
* Trims <js>'/'</js> characters from the end of the specified string. | |
* | |
* @param s The string to trim. | |
* @return The same string buffer. | |
*/ | |
public static StringBuffer trimTrailingSlashes(StringBuffer s) { | |
if (s == null) | |
return null; | |
while (s.length() > 0 && s.charAt(s.length()-1) == '/') | |
s.setLength(s.length()-1); | |
return s; | |
} | |
/** | |
* Shortcut for calling <code>URLEncoder.<jsm>encode</jsm>(o.toString(), <js>"UTF-8"</js>)</code>. | |
* | |
* @param o The object to encode. | |
* @return The URL encoded string, or <jk>null</jk> if the object was null. | |
*/ | |
public static String urlEncode(Object o) { | |
try { | |
if (o != null) | |
return URLEncoder.encode(o.toString(), "UTF-8"); | |
} catch (UnsupportedEncodingException e) {} | |
return null; | |
} | |
/** | |
* Decodes a <code>application/x-www-form-urlencoded</code> string using <code>UTF-8</code> encoding scheme. | |
* | |
* @param s The string to decode. | |
* @return The decoded string, or <jk>null</jk> if input is <jk>null</jk>. | |
*/ | |
public static String urlDecode(String s) { | |
if (s == null) | |
return s; | |
boolean needsDecode = false; | |
for (int i = 0; i < s.length() && ! needsDecode; i++) { | |
char c = s.charAt(i); | |
if (c == '+' || c == '%') | |
needsDecode = true; | |
} | |
if (needsDecode) { | |
try { | |
return URLDecoder.decode(s, "UTF-8"); | |
} catch (UnsupportedEncodingException e) {/* Won't happen */} | |
} | |
return s; | |
} | |
/** | |
* Encodes a <code>application/x-www-form-urlencoded</code> string using <code>UTF-8</code> encoding scheme. | |
* | |
* @param s The string to encode. | |
* @return The encoded string, or <jk>null</jk> if input is <jk>null</jk>. | |
*/ | |
public static String urlEncode(String s) { | |
if (s == null) | |
return null; | |
boolean needsEncode = false; | |
for (int i = 0; i < s.length() && ! needsEncode; i++) | |
needsEncode |= (! unencodedChars.contains(s.charAt(i))); | |
if (needsEncode) { | |
try { | |
return URLEncoder.encode(s, "UTF-8"); | |
} catch (UnsupportedEncodingException e) {/* Won't happen */} | |
} | |
return s; | |
} | |
/** | |
* Splits a string into equally-sized parts. | |
* | |
* @param s The string to split. | |
* @param size The token sizes. | |
* @return The tokens, or <jk>null</jk> if the input was <jk>null</jk>. | |
*/ | |
public static List<String> splitEqually(String s, int size) { | |
if (s == null) | |
return null; | |
if (size <= 0) | |
return Collections.singletonList(s); | |
List<String> l = new ArrayList<>((s.length() + size - 1) / size); | |
for (int i = 0; i < s.length(); i += size) | |
l.add(s.substring(i, Math.min(s.length(), i + size))); | |
return l; | |
} | |
/** | |
* Returns the first non-whitespace character in the string. | |
* | |
* @param s The string to check. | |
* @return | |
* The first non-whitespace character, or <code>0</code> if the string is <jk>null</jk>, empty, or composed | |
* of only whitespace. | |
*/ | |
public static char firstNonWhitespaceChar(String s) { | |
if (s != null) | |
for (int i = 0; i < s.length(); i++) | |
if (! Character.isWhitespace(s.charAt(i))) | |
return s.charAt(i); | |
return 0; | |
} | |
/** | |
* Returns the last non-whitespace character in the string. | |
* | |
* @param s The string to check. | |
* @return | |
* The last non-whitespace character, or <code>0</code> if the string is <jk>null</jk>, empty, or composed | |
* of only whitespace. | |
*/ | |
public static char lastNonWhitespaceChar(String s) { | |
if (s != null) | |
for (int i = s.length()-1; i >= 0; i--) | |
if (! Character.isWhitespace(s.charAt(i))) | |
return s.charAt(i); | |
return 0; | |
} | |
/** | |
* Returns the character at the specified index in the string without throwing exceptions. | |
* | |
* @param s The string. | |
* @param i The index position. | |
* @return | |
* The character at the specified index, or <code>0</code> if the index is out-of-range or the string | |
* is <jk>null</jk>. | |
*/ | |
public static char charAt(String s, int i) { | |
if (s == null) | |
return 0; | |
if (i < 0 || i >= s.length()) | |
return 0; | |
return s.charAt(i); | |
} | |
/** | |
* Efficiently determines whether a URL is of the pattern "xxx://xxx" | |
* | |
* @param s The string to test. | |
* @return <jk>true</jk> if it's an absolute path. | |
*/ | |
public static boolean isAbsoluteUri(String s) { | |
if (isEmpty(s)) | |
return false; | |
// Use a state machine for maximum performance. | |
int S1 = 1; // Looking for http | |
int S2 = 2; // Found http, looking for : | |
int S3 = 3; // Found :, looking for / | |
int S4 = 4; // Found /, looking for / | |
int S5 = 5; // Found /, looking for x | |
int state = S1; | |
for (int i = 0; i < s.length(); i++) { | |
char c = s.charAt(i); | |
if (state == S1) { | |
if (c >= 'a' && c <= 'z') | |
state = S2; | |
else | |
return false; | |
} else if (state == S2) { | |
if (c == ':') | |
state = S3; | |
else if (c < 'a' || c > 'z') | |
return false; | |
} else if (state == S3) { | |
if (c == '/') | |
state = S4; | |
else | |
return false; | |
} else if (state == S4) { | |
if (c == '/') | |
state = S5; | |
else | |
return false; | |
} else if (state == S5) { | |
return true; | |
} | |
} | |
return false; | |
} | |
/** | |
* Efficiently determines whether a URL is of the pattern "xxx:/xxx". | |
* | |
* <p> | |
* The pattern matched is: <code>[a-z]{2,}\:\/.*</code> | |
* | |
* <p> | |
* Note that this excludes filesystem paths such as <js>"C:/temp"</js>. | |
* | |
* @param s The string to test. | |
* @return <jk>true</jk> if it's an absolute path. | |
*/ | |
public static boolean isUri(String s) { | |
if (isEmpty(s)) | |
return false; | |
// Use a state machine for maximum performance. | |
int S1 = 1; // Looking for protocol char 1 | |
int S2 = 2; // Found protocol char 1, looking for protocol char 2 | |
int S3 = 3; // Found protocol char 2, looking for : | |
int S4 = 4; // Found :, looking for / | |
int state = S1; | |
for (int i = 0; i < s.length(); i++) { | |
char c = s.charAt(i); | |
if (state == S1) { | |
if (c >= 'a' && c <= 'z') | |
state = S2; | |
else | |
return false; | |
} else if (state == S2) { | |
if (c >= 'a' && c <= 'z') | |
state = S3; | |
else | |
return false; | |
} else if (state == S3) { | |
if (c == ':') | |
state = S4; | |
else if (c < 'a' || c > 'z') | |
return false; | |
} else if (state == S4) { | |
if (c == '/') | |
return true; | |
return false; | |
} | |
} | |
return false; | |
} | |
/** | |
* Given an absolute URI, returns just the authority portion (e.g. <js>"http://hostname:port"</js>) | |
* | |
* @param s The URI string. | |
* @return Just the authority portion of the URI. | |
*/ | |
public static String getAuthorityUri(String s) { | |
// Use a state machine for maximum performance. | |
int S1 = 1; // Looking for http | |
int S2 = 2; // Found http, looking for : | |
int S3 = 3; // Found :, looking for / | |
int S4 = 4; // Found /, looking for / | |
int S5 = 5; // Found /, looking for x | |
int S6 = 6; // Found x, looking for / | |
int state = S1; | |
for (int i = 0; i < s.length(); i++) { | |
char c = s.charAt(i); | |
if (state == S1) { | |
if (c >= 'a' && c <= 'z') | |
state = S2; | |
else | |
return s; | |
} else if (state == S2) { | |
if (c == ':') | |
state = S3; | |
else if (c < 'a' || c > 'z') | |
return s; | |
} else if (state == S3) { | |
if (c == '/') | |
state = S4; | |
else | |
return s; | |
} else if (state == S4) { | |
if (c == '/') | |
state = S5; | |
else | |
return s; | |
} else if (state == S5) { | |
if (c != '/') | |
state = S6; | |
else | |
return s; | |
} else if (state == S6) { | |
if (c == '/') | |
return s.substring(0, i); | |
} | |
} | |
return s; | |
} | |
/** | |
* Converts the specified object to a URI. | |
* | |
* @param o The object to convert to a URI. | |
* @return A new URI, or the same object if the object was already a URI, or | |
*/ | |
public static URI toURI(Object o) { | |
if (o == null || o instanceof URI) | |
return (URI)o; | |
try { | |
return new URI(o.toString()); | |
} catch (URISyntaxException e) { | |
throw new RuntimeException(e); | |
} | |
} | |
/** | |
* Returns the first non-null, non-empty string in the list. | |
* | |
* @param s The strings to test. | |
* @return The first non-empty string in the list, or <jk>null</jk> if they were all <jk>null</jk> or empty. | |
*/ | |
public static String firstNonEmpty(String...s) { | |
for (String ss : s) | |
if (! isEmpty(ss)) | |
return ss; | |
return null; | |
} | |
/** | |
* Same as {@link String#indexOf(int)} except allows you to check for multiple characters. | |
* | |
* @param s The string to check. | |
* @param c The characters to check for. | |
* @return The index into the string that is one of the specified characters. | |
*/ | |
public static int indexOf(String s, char...c) { | |
if (s == null) | |
return -1; | |
for (int i = 0; i < s.length(); i++) { | |
char c2 = s.charAt(i); | |
for (char cc : c) | |
if (c2 == cc) | |
return i; | |
} | |
return -1; | |
} | |
/** | |
* Similar to {@link MessageFormat#format(String, Object...)} except allows you to specify POJO arguments. | |
* | |
* @param pattern The string pattern. | |
* @param args The arguments. | |
* @return The formatted string. | |
*/ | |
public static String format(String pattern, Object...args) { | |
if (args == null || args.length == 0) | |
return pattern; | |
for (int i = 0; i < args.length; i++) | |
args[i] = convertToReadable(args[i]); | |
return MessageFormat.format(pattern, args); | |
} | |
private static Object convertToReadable(Object o) { | |
if (o == null) | |
return null; | |
if (o instanceof ClassMeta) | |
return ((ClassMeta<?>)o).getReadableName(); | |
if (BeanContext.DEFAULT == null) | |
return o.toString(); | |
ClassMeta<?> cm = BeanContext.DEFAULT.getClassMetaForObject(o); | |
if (cm.isMapOrBean() || cm.isCollectionOrArray()) | |
return JsonSerializer.DEFAULT_LAX.toString(o); | |
if (cm.isClass()) | |
return ((Class<?>)o).getName(); | |
if (cm.isMethod()) | |
return ClassUtils.toString((Method)o); | |
return o.toString(); | |
} | |
/** | |
* Converts a string containing a possible multiplier suffix to an integer. | |
* | |
* <p> | |
* The string can contain any of the following multiplier suffixes: | |
* <ul> | |
* <li><js>"K"</js> - x 1024 | |
* <li><js>"M"</js> - x 1024*1024 | |
* <li><js>"G"</js> - x 1024*1024*1024 | |
* </ul> | |
* | |
* @param s The string to parse. | |
* @return The parsed value. | |
*/ | |
public static int parseIntWithSuffix(String s) { | |
assertFieldNotNull(s, "s"); | |
int m = 1; | |
if (s.endsWith("G")) { | |
m = 1024*1024*1024; | |
s = s.substring(0, s.length()-1).trim(); | |
} else if (s.endsWith("M")) { | |
m = 1024*1024; | |
s = s.substring(0, s.length()-1).trim(); | |
} else if (s.endsWith("K")) { | |
m = 1024; | |
s = s.substring(0, s.length()-1).trim(); | |
} | |
return Integer.decode(s) * m; | |
} | |
/** | |
* Converts a string containing a possible multiplier suffix to a long. | |
* | |
* <p> | |
* The string can contain any of the following multiplier suffixes: | |
* <ul> | |
* <li><js>"K"</js> - x 1024 | |
* <li><js>"M"</js> - x 1024*1024 | |
* <li><js>"G"</js> - x 1024*1024*1024 | |
* </ul> | |
* | |
* @param s The string to parse. | |
* @return The parsed value. | |
*/ | |
public static long parseLongWithSuffix(String s) { | |
assertFieldNotNull(s, "s"); | |
int m = 1; | |
if (s.endsWith("G")) { | |
m = 1024*1024*1024; | |
s = s.substring(0, s.length()-1).trim(); | |
} else if (s.endsWith("M")) { | |
m = 1024*1024; | |
s = s.substring(0, s.length()-1).trim(); | |
} else if (s.endsWith("K")) { | |
m = 1024; | |
s = s.substring(0, s.length()-1).trim(); | |
} | |
return Long.decode(s) * m; | |
} | |
/** | |
* Same as {@link String#contains(CharSequence)} except returns <jk>null</jk> if the value is null. | |
* | |
* @param value The string to check. | |
* @param substring The value to check for. | |
* @return <jk>true</jk> if the value contains the specified substring. | |
*/ | |
public static boolean contains(String value, CharSequence substring) { | |
return value == null ? false : value.contains(substring); | |
} | |
/** | |
* Returns <jk>true</jk> if the specified string appears to be an JSON array. | |
* | |
* @param o The object to test. | |
* @return <jk>true</jk> if the specified string appears to be a JSON array. | |
*/ | |
public static boolean isObjectList(Object o) { | |
if (o instanceof CharSequence) { | |
String s = o.toString(); | |
return (s.startsWith("[") && s.endsWith("]") && BeanContext.DEFAULT != null); | |
} | |
return false; | |
} | |
/** | |
* Returns <jk>true</jk> if the specified string appears to be a JSON object. | |
* | |
* @param o The object to test. | |
* @return <jk>true</jk> if the specified string appears to be a JSON object. | |
*/ | |
public static boolean isObjectMap(Object o) { | |
if (o instanceof CharSequence) { | |
String s = o.toString(); | |
return (s.startsWith("{") && s.endsWith("}") && BeanContext.DEFAULT != null); | |
} | |
return false; | |
} | |
} |