package com.spun.util;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Vector;
import org.lambda.functions.implementations.F1;
import org.lambda.query.Query;
/**
* A static class of convenience functions for database access
**/
public class StringUtils
{
public static final String NEW_LINE = System.getProperty("line.separator");
/***********************************************************************/
public static String toURLEncode(String input)
{
try
{
return input == null ? null : java.net.URLEncoder.encode(input, "UTF-8");
}
catch (UnsupportedEncodingException e)
{
throw ObjectUtils.throwAsError(e);
}
}
/***********************************************************************/
public static String loadNullableString(String i)
{
return StringUtils.isNonZero(i) ? i.trim() : null;
}
/***********************************************************************/
/**
* Decode a URLEncoded <code>input</code> String.
* <p>
*
* If <code>input</code> is <code>null</code>, <code>URLEncode()</code> will
* return <code>null</code>.
*
* @see java.net.URLDecoder
*/
public static String URLDecode(String input)
{
try
{
return input == null ? null : java.net.URLDecoder.decode(input, "UTF-8");
}
catch (Exception e)
{
return null;
}
}
/************************************************************************/
public static String[] split(String string, String splitOn)
{
return split(string, splitOn, true);
}
/************************************************************************/
public static String[] split(String string, String splitOn, boolean trim)
{
if ((string == null) || (splitOn == null) || (splitOn.length() < 1)) { return null; }
Vector<String> temp = new Vector<String>();
int length = splitOn.length();
int start = 0;
int next = 0;
while (next != -1)
{
String word = null;
next = string.indexOf(splitOn, start);
if (next == -1)
{
word = string.substring(start);
}
else
{
word = string.substring(start, next);
start = next + length;
}
temp.add(trim ? word.trim() : word);
}
return toArray(temp);
}
/************************************************************************/
public static String replace(String string, String find, String replace)
{
if ((string == null) || (find == null) || (replace == null)) { throw new NullPointerException(
String.format("[string,find,replace] = [%s,%s,%s]", string, find, replace)); }
String parts[] = split(string, find, false);
if (parts.length == 1) { return string; }
String result = "";
for (int i = 0; i < parts.length; i++)
{
result += parts[i] + replace;
}
return result.substring(0, result.length() - replace.length());
}
/***********************************************************************/
public static String stripWhiteSpace(String text)
{
return stripWhiteSpace(text, false);
}
/***********************************************************************/
public static String padNumber(long number, int digits)
{
String text = "" + number;
while (text.length() < digits)
{
text = "0" + text;
}
return text;
}
/***********************************************************************/
public static String padNumber(int number, int digits)
{
return padNumber((long) number, digits);
}
/***********************************************************************/
public static String stripWhiteSpace(String text, boolean all)
{
StringBuffer newText = new StringBuffer();
boolean whitespace = false;
int num = text.length();
char whiteSpaceChar = ' ';
boolean atStart = true;
for (int i = 0; i < num; i++)
{
char c = text.charAt(i);
switch (c)
{
case '\r' :
case '\n' :
whiteSpaceChar = '\n';
whitespace = true;
break;
case '\t' :
case ' ' :
whitespace = true;
break;
default :
if (whitespace && atStart)
{
whitespace = false;
}
if (whitespace)
{
whitespace = false;
newText.append(all ? '_' : whiteSpaceChar);
whiteSpaceChar = ' ';
}
atStart = false;
newText.append(c);
break;
}
}
return newText.toString();
}
/************************************************************************/
/**
* Turns "mr. frank m Peter" into "Mr. Frank M Peter"
**/
public static String toNameUpperCase(String name)
{
if (name == null) { return null; }
StringBuffer returning = new StringBuffer(name.length());
String upper = name.toUpperCase();
int place = 0;
while (place < name.length())
{
char letter = name.charAt(place);
if (letter == ' ')
{
returning.append(' ');
if ((place + 1) < name.length())
{
returning.append(upper.charAt(++place));
}
}
else if ((place == 0))
{
returning.append(upper.charAt(0));
}
else
{
returning.append(letter);
}
place++;
}
return returning.toString();
}
/************************************************************************/
public static String toConvertCamelCaseString(String varName, String insertBeforeCaps)
{
StringBuffer staticVarName = new StringBuffer();
for (int i = 0; i < varName.length(); i++)
{
char letter = varName.charAt(i);
if ((i > 0) && (letter == Character.toUpperCase(letter)) && Character.isLetter(letter))
{
staticVarName.append(insertBeforeCaps);
}
staticVarName.append(letter);
}
return staticVarName.toString();
}
/************************************************************************/
/**
* Turns "ATTRIUBE_NAME" into "AttributeName"
**/
public static String toMethodNameCase(String name)
{
StringBuffer returning = new StringBuffer(name.length());
String upper = name.toUpperCase();
String lower = name.toLowerCase();
int place = 0;
while (place < name.length())
{
char letter = lower.charAt(place);
if (letter == ' ' || letter == '_')
{
if ((place + 1) < name.length())
{
returning.append(upper.charAt(++place));
}
}
else if ((place == 0))
{
returning.append(upper.charAt(0));
}
else
{
returning.append(letter);
}
place++;
}
return returning.toString();
}
/************************************************************************/
public static String stripNonNumeric(String number)
{
return stripNonNumeric(number, false, false);
}
/************************************************************************/
public static String stripCharacters(String dirtyString, String toStrip)
{
StringBuffer cleanStringBuffer = new StringBuffer();
for (int i = 0; i < dirtyString.length(); i++)
{
char currentChar = dirtyString.charAt(i);
if (toStrip.indexOf(currentChar) == -1)
{
cleanStringBuffer.append(currentChar);
}
}
return cleanStringBuffer.toString();
}
public static String escapeForXml(String string)
{
return string.replaceAll("&", "&");
}
/************************************************************************/
public static String stripNonNumeric(String number, boolean allowDecimal, boolean allowNegative)
{
boolean allowExponential = allowDecimal;
boolean afterE = false;
if (number == null) { return ""; }
StringBuffer result = new StringBuffer();
for (int i = 0; i < number.length(); i++)
{
char c = number.charAt(i);
switch (c)
{
case '0' :
case '1' :
case '2' :
case '3' :
case '4' :
case '5' :
case '6' :
case '7' :
case '8' :
case '9' :
result.append(c);
afterE = false;
break;
case '-' :
if (allowNegative || afterE)
{
result.append(c);
allowNegative = false;
}
break;
case '.' :
if (allowDecimal)
{
result.append(c);
allowDecimal = false;
}
afterE = false;
break;
case 'e' :
case 'E' :
if (allowExponential)
{
result.append(c);
allowExponential = false;
}
afterE = true;
break;
default :
break;
}
}
return result.toString();
}
/***********************************************************************/
/**
* A convenience function to check that a String has at least 1 character.
*
* @param string
* The string in question
* @return true if Non Zero.
**/
public static boolean isNonZero(String string)
{
return ((string != null) && string.trim().length() > 0);
}
/***********************************************************************/
public static boolean isEmpty(String string)
{
return !isNonZero(string);
}
/************************************************************************/
/**
* A convenience function to turn a vector of String objects into an Array
* of the String objects.
*
* @param vectorOf
* a Vector of String objects
* @return the array of String.
* @throws Error
* if an element of vectorOf is not a String object.
**/
public static String[] toArray(java.util.Collection<String> vectorOf)
{
if (vectorOf == null) { return new String[0]; }
String array[] = new String[vectorOf.size()];
java.util.Iterator<String> iterator = vectorOf.iterator();
int i = 0;
while (iterator.hasNext())
{
java.lang.Object rowObject = iterator.next();
if (rowObject instanceof String)
{
array[i++] = (String) rowObject;
}
else
{
throw new Error(
"toArray[" + i + "] is not an instance of String but a " + ObjectUtils.getClassName(rowObject));
}
}
return array;
}
/***********************************************************************/
public static int resolveEnumeration(String value, String[] enumeration)
{
return resolveEnumeration(value, enumeration, false);
}
/***********************************************************************/
public static int resolveEnumeration(String value, String[] enumeration, boolean force)
{
for (int i = 0; i < enumeration.length; i++)
{
if (enumeration[i].equals(value)) { return i; }
}
if (force) { throw new Error("Enumeration '" + value + "' not in " + Arrays.asList(enumeration).toString()); }
return -1;
}
/***********************************************************************/
public static String truncate(String string, int maxLength)
{
if (string == null) { return null; }
return (string.length() <= maxLength) ? string : string.substring(0, maxLength);
}
/***********************************************************************/
public static boolean hasNumeric(String teamId)
{
return isNonZero(stripNonNumeric(teamId, false, false));
}
/***********************************************************************/
public static String toHTMLEncode(String string)
{
if (string == null) { return null; }
string = string.replaceAll("<", "<");
string = string.replaceAll("\n", "<br />");
return string;
}
/***********************************************************************/
public static String toJavaScriptEncode(String string)
{
if (string == null) { return "null"; }
string = string.replaceAll("\"", "\\\\\"");
string = string.replaceAll("\r", "\\\\r");
string = string.replaceAll("\n", "\\\\n");
return "\"" + string + "\"";
}
/***********************************************************************/
public static boolean isIn(String target, String... fromList)
{
return Arrays.asList(fromList).contains(target);
}
/***********************************************************************/
public static boolean isIn(String target, String[] fromList, boolean allowNulls)
{
return (target == null && allowNulls) ? true : isIn(target, fromList);
}
/************************************************************************/
public static void assertIn(String target, String[] fromList, boolean allowNulls)
{
boolean valid = isIn(target, fromList, allowNulls);
if (!valid) { throw new IllegalArgumentException(
"The value '" + target + "' not in " + Arrays.asList(fromList)); }
}
public static void assertIn(String target, boolean allowNulls, String... options)
{
assertIn(target, options, allowNulls);
}
/***********************************************************************/
public static String convertEnumeration(final Object forValue, Class<?> clazz) throws Exception
{
F1<Field, Boolean> f1 = new F1<Field, Boolean>(null, forValue)
{
{
ret(ClassUtils.IsPublicStatic(a) && a.get(null).equals(forValue));
}
};
List<Field> fields = Query.where(clazz.getFields(), f1);
if (fields.isEmpty())
{
return "unknown Type " + forValue;
}
else
{
return fields.get(0).getName();
}
}
/************************************************************************/
/**
* 'Tom S Hardy' -> 'Tom S' - 'Hardy'
**/
public static String[] splitName(String fullName)
{
String names[] = {null, null};
int split = fullName.lastIndexOf(' ');
if (split != -1)
{
names[0] = fullName.substring(0, split);
names[1] = fullName.substring(split);
}
else
{
names[1] = fullName;
}
return names;
}
/***********************************************************************/
public static Properties createProperties(String[] properties)
{
Properties props = new Properties();
if (properties == null) { return props; }
if (properties.length % 2 != 0) { throw new Error(
"number of strings must be even. found [" + properties.length + "] = " + Arrays.asList(properties)); }
for (int i = 0; i < properties.length; i += 2)
{
if (properties[i + 1] != null)
{
props.setProperty(properties[i], properties[i + 1]);
}
else
{
props.setProperty(properties[i], "");
}
}
return props;
}
/***********************************************************************/
public static <T> String toString(String name, T[] array)
{
StringBuffer buffer = new StringBuffer();
name = (name == null ? "array" : name);
if (array == null || array.length == 0)
{
buffer.append(name + ".length = 0");
}
else
{
int maxPadding = ("" + array.length).length();
for (int i = 0; i < array.length; i++)
{
buffer.append(name + "[" + padNumber(i, maxPadding) + "] = " + array[i] + "\n");
}
}
return buffer.toString();
}
/***********************************************************************/
public static <T> String toString(String name, Iterable<T> array)
{
StringBuffer buffer = new StringBuffer();
name = (name == null ? "array" : name);
if (array != null)
{
int count = 0;
for (T t : array)
{
buffer.append(name + "[" + count + "] = " + arrayStringHelper(t) + "\n");
count++;
}
}
if (buffer.length() == 0)
{
buffer.append(name + ".length = 0");
}
return buffer.toString();
}
public static String arrayStringHelper(Object o)
{
if (o == null) { return "null"; }
return o.getClass().isArray() ? Arrays.toString((Object[]) o) : o.toString();
}
/***********************************************************************/
public static String getFirstName(String fullName)
{
return splitName(fullName)[0];
}
/***********************************************************************/
public static String getLastName(String fullName)
{
return splitName(fullName)[1];
}
/************************************************************************/
public static boolean isLengthWithin(String string, int length)
{
return string == null || string.length() <= length;
}
/************************************************************************/
public static boolean equalsIgnoreCase(String one, String two)
{
return (one == two || (one != null && one.equalsIgnoreCase(two)));
}
/***********************************************************************/
public static StringBuffer trim(StringBuffer buffer, int i)
{
if (buffer == null || buffer.length() < i) { return buffer; }
buffer.setLength(buffer.length() - i);
return buffer;
}
/***********************************************************************/
public static String join(String first, String joinBy, String second)
{
return isEmpty(second) ? first : first + joinBy + second;
}
/***********************************************************************/
/***********************************************************************/
public static InputStream convertToInputStream(String string)
{
return new ByteArrayInputStream(string.getBytes());
}
public static String toString(Map map)
{
StringBuffer b = new StringBuffer();
Object keySet[] = map.keySet().toArray();
Arrays.sort(keySet);
for (Object key : keySet)
{
b.append(String.format("%s : %s \n", key, map.get(key)));
}
return b.toString();
}
}