/*
* 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.openjpa.lib.util;
import java.util.ArrayList;
import java.util.List;
public final class StringUtil {
private static final String[] EMPTY_STRING_ARRAY = new String[0];
private static final Byte BYTE_ZERO = Byte.valueOf((byte) 0);
private static final Character CHAR_ZERO = Character.valueOf((char) 0);
private static final Double DOUBLE_ZERO = Double.valueOf(0.0d);
private static final Float FLOAT_ZERO = Float.valueOf(0.0f);
private static final Integer INTEGER_ZERO = Integer.valueOf(0);
private static final Long LONG_ZERO = Long.valueOf(0);
private static final Short SHORT_ZERO = Short.valueOf((short) 0);
private StringUtil() {
}
/**
* @return {@code true} if the given string is null or empty.
*/
public static boolean isEmpty(String val) {
return val == null || val.isEmpty();
}
public static boolean isNotEmpty(String val) {
return !isEmpty(val);
}
/**
* <p>Checks if a CharSequence is whitespace, empty ("") or null.</p>
*
* <pre>
* StringUtils.isBlank(null) = true
* StringUtils.isBlank("") = true
* StringUtils.isBlank(" ") = true
* StringUtils.isBlank("bob") = false
* StringUtils.isBlank(" bob ") = false
* </pre>
*
* Ported over from Apache commons-lang3
*
* @param cs the CharSequence to check, may be null
* @return {@code true} if the CharSequence is null, empty or whitespace
*/
public static boolean isBlank(final CharSequence cs) {
int strLen;
if (cs == null || (strLen = cs.length()) == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if (Character.isWhitespace(cs.charAt(i)) == false) {
return false;
}
}
return true;
}
/**
* <p>Checks if a CharSequence is not empty (""), not null and not whitespace only.</p>
*
* <pre>
* StringUtils.isNotBlank(null) = false
* StringUtils.isNotBlank("") = false
* StringUtils.isNotBlank(" ") = false
* StringUtils.isNotBlank("bob") = true
* StringUtils.isNotBlank(" bob ") = true
* </pre>
*
* Ported over from Apache commons-lang3
*
* @param cs the CharSequence to check, may be null
* @return {@code true} if the CharSequence is not empty and not null and not whitespace
*/
public static boolean isNotBlank(final CharSequence cs) {
return !isBlank(cs);
}
/**
* @param val the string to search in
* @param charToSearchFor the character to search for
* @return {@code true} if the charToSearchFor is contained in the String val
*/
public static boolean contains(String val, char charToSearchFor) {
return val != null && val.indexOf(charToSearchFor) > -1;
}
public static boolean equalsIgnoreCase(String str1, String str2) {
if (str1 == null || str2 == null) {
return str1 == str2;
}
else if (str1 == str2) {
return true;
}
return str1.equalsIgnoreCase(str2);
}
/**
* Splits the given string on the given token. Follows the semantics
* of the Java 1.4 {@link String#split(String, int)} method, but does
* not treat the given token as a regular expression.
*/
public static String[] split(String str, String token, int max) {
if (str == null || str.length() == 0) {
return EMPTY_STRING_ARRAY;
}
if (token == null || token.length() == 0) {
throw new IllegalArgumentException("token: [" + token + "]");
}
// split on token
List<String> ret = new ArrayList<>();
int start = 0;
int len = str.length();
int tlen = token.length();
int pos = 0;
while (pos != -1) {
pos = str.indexOf(token, start);
if (pos != -1) {
ret.add(str.substring(start, pos));
start = pos + tlen;
}
}
if (start < len) {
ret.add(str.substring(start));
}
else if (start == len) {
ret.add("");
}
// now take max into account; this isn't the most efficient way
// of doing things since we split the maximum number of times
// regardless of the given parameters, but it makes things easy
if (max == 0) {
int size = ret.size();
// discard any trailing empty splits
while (ret.get(--size).isEmpty()) {
ret.remove(size);
}
}
else if (max > 0 && ret.size() > max) {
// move all splits over max into the last split
StringBuilder sb = new StringBuilder(256);
sb.append(ret.get(max - 1));
ret.remove(max - 1);
while (ret.size() >= max) {
sb.append(token).append(ret.get(max - 1));
ret.remove(max - 1);
}
ret.add(sb.toString());
}
return ret.toArray(new String[ret.size()]);
}
/**
* Replace all instances of <code>from</code> in <code>str</code>
* with <code>to</code>.
*
* @param str the candidate string to replace
* @param from the token to replace
* @param to the new token
* @return the string with all the replacements made
*/
public static String replace(String str, String from, String to) {
if (from.equals(to)) {
return str;
}
String[] split = split(str, from, Integer.MAX_VALUE);
return join(split, to);
}
/**
* Null-safe {@link String#trim()}
*/
public static String trim(final String str) {
return str == null ? null : str.trim();
}
/**
* @return the trimmed string str or {@code null} if the trimmed string would be empty.
*/
public static String trimToNull(String str) {
if (str == null || str.isEmpty()) {
return null;
}
str = str.trim();
if (str.isEmpty()) {
return null;
}
return str;
}
public static String join(Object[] values, String joinToken) {
if (values == null) {
return null;
}
if (values.length == 0) {
return "";
}
if (values.length == 1) {
return values[0].toString();
}
if (joinToken == null) {
joinToken = "null"; // backward compat with commons-lang StringUtils...
}
StringBuilder sb = new StringBuilder(values.length * (16 + joinToken.length()));
sb.append(values[0]);
for (int i = 1; i < values.length; i++) {
sb.append(joinToken).append(values[i]);
}
return sb.toString();
}
/**
* Parse the given
*
* @param val value to parse
* @param type the target type of the the parsed value
* @return the converted value
*/
public static <T> T parse(String val, Class<T> type) {
if (type == null) {
throw new NullPointerException("target type must not be null");
}
// handle primitives
if (type == byte.class) {
return (T) (val == null ? BYTE_ZERO : Byte.valueOf(val));
}
if (type == char.class) {
return (T) (val == null ? CHAR_ZERO : parseCharString(val));
}
if (type == double.class) {
return (T) (val == null ? DOUBLE_ZERO : Double.valueOf(val));
}
if (type == float.class) {
return (T) (val == null ? FLOAT_ZERO : Float.valueOf(val));
}
if (type == int.class) {
return (T) (val == null ? INTEGER_ZERO : Integer.valueOf(val));
}
if (type == long.class) {
return (T) (val == null ? LONG_ZERO : Long.valueOf(val));
}
if (type == short.class) {
return (T) (val == null ? SHORT_ZERO : Short.valueOf(val));
}
if (type == boolean.class) {
return (T) (val == null ? Boolean.FALSE : Boolean.valueOf(val));
}
if (type == void.class) {
throw new IllegalStateException("Cannot parse void type");
}
// handle wrapper types
if (type == Byte.class) {
return (T) (val == null ? null : Byte.valueOf(val));
}
if (type == Character.class) {
return (T) (val == null ? null : parseCharString(val));
}
if (type == Double.class) {
return (T) (val == null ? null : Double.valueOf(val));
}
if (type == Float.class) {
return (T) (val == null ? null : Float.valueOf(val));
}
if (type == Integer.class) {
return (T) (val == null ? null : Integer.valueOf(val));
}
if (type == Long.class) {
return (T) (val == null ? null : Long.valueOf(val));
}
if (type == Short.class) {
return (T) (val == null ? null : Short.valueOf(val));
}
if (type == Boolean.class) {
return (T) (val == null ? null : Boolean.valueOf(val));
}
throw new IllegalArgumentException("Unsupported type: " + type.getCanonicalName());
}
/**
* <p>Capitalizes a String changing the first letter to title case as
* per {@link Character#toTitleCase(char)}. No other letters are changed.</p>
*
*
* <pre>
* StringUtil.capitalize(null) = null
* StringUtil.capitalize("") = ""
* StringUtil.capitalize("cat") = "Cat"
* StringUtil.capitalize("cAt") = "CAt"
* </pre>
*
* Ported over from Apache commons-lang3
*
* @param str the String to capitalize, may be null
* @return the capitalized String, {@code null} if null String input
* @see #uncapitalize(String)
*/
public static String capitalize(final String str) {
int strLen;
if (str == null || (strLen = str.length()) == 0) {
return str;
}
final char firstChar = str.charAt(0);
if (Character.isTitleCase(firstChar)) {
// already capitalized
return str;
}
return new StringBuilder(strLen)
.append(Character.toTitleCase(firstChar))
.append(str.substring(1))
.toString();
}
/**
* <p>Uncapitalizes a String changing the first letter to title case as
* per {@link Character#toLowerCase(char)}. No other letters are changed.</p>
*
* <pre>
* StringUtil.uncapitalize(null) = null
* StringUtil.uncapitalize("") = ""
* StringUtil.uncapitalize("Cat") = "cat"
* StringUtil.uncapitalize("CAT") = "cAT"
* </pre>
*
* Ported over from Apache commons-lang3
*
* @param str the String to uncapitalize, may be null
* @return the uncapitalized String, {@code null} if null String input
* @see #capitalize(String)
*/
public static String uncapitalize(final String str) {
int strLen;
if (str == null || (strLen = str.length()) == 0) {
return str;
}
final char firstChar = str.charAt(0);
if (Character.isLowerCase(firstChar)) {
// already uncapitalized
return str;
}
return new StringBuilder(strLen)
.append(Character.toLowerCase(firstChar))
.append(str.substring(1))
.toString();
}
public static boolean endsWithIgnoreCase(String str, String suffix) {
if (str == null || suffix == null) {
return str == null && suffix == null;
}
int strlen = str.length();
if (suffix.length() > strlen) {
return false;
}
return str.substring(str.length() - suffix.length(), strlen).equalsIgnoreCase(suffix);
}
/**
* <p>Strips any of a set of characters from the end of a String.</p>
*
* <p>A {@code null} input String returns {@code null}.
* An empty string ("") input returns the empty string.</p>
*
* <p>If the stripChars String is {@code null}, whitespace is
* stripped as defined by {@link Character#isWhitespace(char)}.</p>
*
* <pre>
* StringUtils.stripEnd(null, *) = null
* StringUtils.stripEnd("", *) = ""
* StringUtils.stripEnd("abc", "") = "abc"
* StringUtils.stripEnd("abc", null) = "abc"
* StringUtils.stripEnd(" abc", null) = " abc"
* StringUtils.stripEnd("abc ", null) = "abc"
* StringUtils.stripEnd(" abc ", null) = " abc"
* StringUtils.stripEnd(" abcyx", "xyz") = " abc"
* StringUtils.stripEnd("120.00", ".0") = "12"
* </pre>
*
* Ported over from Apache commons-lang3
*
* @param str the String to remove characters from, may be null
* @param stripChars the set of characters to remove, null treated as whitespace
* @return the stripped String, {@code null} if null String input
*/
public static String stripEnd(final String str, final String stripChars) {
int end;
if (str == null || (end = str.length()) == 0) {
return str;
}
if (stripChars == null) {
while (end != 0 && Character.isWhitespace(str.charAt(end - 1))) {
end--;
}
} else if (stripChars.isEmpty()) {
return str;
} else {
while (end != 0 && stripChars.indexOf(str.charAt(end - 1)) != -1) {
end--;
}
}
return str.substring(0, end);
}
private static Character parseCharString(String val) {
if (val.length() == 0) {
return Character.valueOf((char) 0);
}
if (val.length() == 1) {
return val.charAt(0);
}
throw new IllegalArgumentException("'" + val + "' is longer than one character.");
}
}