640 lines
18 KiB
Plaintext
Executable File
640 lines
18 KiB
Plaintext
Executable File
package com.fp.general.helper;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Iterator;
|
|
import java.util.StringTokenizer;
|
|
|
|
import org.hibernate.dialect.Dialect;
|
|
|
|
|
|
// Referenced classes of package org.hibernate.util:
|
|
// ArrayHelper
|
|
|
|
public final class StringHelper
|
|
{
|
|
|
|
private static final int ALIAS_TRUNCATE_LENGTH = 10;
|
|
public static final String WHITESPACE = " \n\r\f\t";
|
|
|
|
private StringHelper()
|
|
{
|
|
}
|
|
|
|
public static int lastIndexOfLetter(String string)
|
|
{
|
|
for(int i = 0; i < string.length(); i++)
|
|
{
|
|
char character = string.charAt(i);
|
|
if(!Character.isLetter(character))
|
|
{
|
|
return i - 1;
|
|
}
|
|
}
|
|
|
|
return string.length() - 1;
|
|
}
|
|
|
|
public static String join(String seperator, String strings[])
|
|
{
|
|
int length = strings.length;
|
|
if(length == 0)
|
|
{
|
|
return "";
|
|
}
|
|
StringBuffer buf = (new StringBuffer(length * strings[0].length())).append(strings[0]);
|
|
for(int i = 1; i < length; i++)
|
|
{
|
|
buf.append(seperator).append(strings[i]);
|
|
}
|
|
|
|
return buf.toString();
|
|
}
|
|
|
|
public static String join(String seperator, Iterator objects)
|
|
{
|
|
StringBuffer buf = new StringBuffer();
|
|
if(objects.hasNext())
|
|
{
|
|
buf.append(objects.next());
|
|
}
|
|
for(; objects.hasNext(); buf.append(seperator).append(objects.next())) { }
|
|
return buf.toString();
|
|
}
|
|
|
|
public static String[] add(String x[], String sep, String y[])
|
|
{
|
|
String result[] = new String[x.length];
|
|
for(int i = 0; i < x.length; i++)
|
|
{
|
|
result[i] = (new StringBuilder()).append(x[i]).append(sep).append(y[i]).toString();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static String repeat(String string, int times)
|
|
{
|
|
StringBuffer buf = new StringBuffer(string.length() * times);
|
|
for(int i = 0; i < times; i++)
|
|
{
|
|
buf.append(string);
|
|
}
|
|
|
|
return buf.toString();
|
|
}
|
|
|
|
public static String repeat(char character, int times)
|
|
{
|
|
char buffer[] = new char[times];
|
|
Arrays.fill(buffer, character);
|
|
return new String(buffer);
|
|
}
|
|
|
|
public static String replace(String template, String placeholder, String replacement)
|
|
{
|
|
return replace(template, placeholder, replacement, false);
|
|
}
|
|
|
|
public static String[] replace(String templates[], String placeholder, String replacement)
|
|
{
|
|
String result[] = new String[templates.length];
|
|
for(int i = 0; i < templates.length; i++)
|
|
{
|
|
result[i] = replace(templates[i], placeholder, replacement);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static String replace(String template, String placeholder, String replacement, boolean wholeWords)
|
|
{
|
|
return replace(template, placeholder, replacement, wholeWords, false);
|
|
}
|
|
|
|
public static String replace(String template, String placeholder, String replacement, boolean wholeWords, boolean encloseInParensIfNecessary)
|
|
{
|
|
if(template == null)
|
|
{
|
|
return template;
|
|
}
|
|
int loc = template.indexOf(placeholder);
|
|
if(loc < 0)
|
|
{
|
|
return template;
|
|
} else
|
|
{
|
|
String beforePlaceholder = template.substring(0, loc);
|
|
String afterPlaceholder = template.substring(loc + placeholder.length());
|
|
return replace(beforePlaceholder, afterPlaceholder, placeholder, replacement, wholeWords, encloseInParensIfNecessary);
|
|
}
|
|
}
|
|
|
|
public static String replace(String beforePlaceholder, String afterPlaceholder, String placeholder, String replacement, boolean wholeWords, boolean encloseInParensIfNecessary)
|
|
{
|
|
boolean actuallyReplace = !wholeWords || afterPlaceholder.length() == 0 || !Character.isJavaIdentifierPart(afterPlaceholder.charAt(0));
|
|
boolean encloseInParens = actuallyReplace && encloseInParensIfNecessary && getLastNonWhitespaceCharacter(beforePlaceholder) != '(' && getFirstNonWhitespaceCharacter(afterPlaceholder) != ')';
|
|
StringBuilder buf = new StringBuilder(beforePlaceholder);
|
|
if(encloseInParens)
|
|
{
|
|
buf.append('(');
|
|
}
|
|
buf.append(actuallyReplace ? replacement : placeholder);
|
|
if(encloseInParens)
|
|
{
|
|
buf.append(')');
|
|
}
|
|
buf.append(replace(afterPlaceholder, placeholder, replacement, wholeWords, encloseInParensIfNecessary));
|
|
return buf.toString();
|
|
}
|
|
|
|
public static char getLastNonWhitespaceCharacter(String str)
|
|
{
|
|
if(str != null && str.length() > 0)
|
|
{
|
|
for(int i = str.length() - 1; i >= 0; i--)
|
|
{
|
|
char ch = str.charAt(i);
|
|
if(!Character.isWhitespace(ch))
|
|
{
|
|
return ch;
|
|
}
|
|
}
|
|
|
|
}
|
|
return '\0';
|
|
}
|
|
|
|
public static char getFirstNonWhitespaceCharacter(String str)
|
|
{
|
|
if(str != null && str.length() > 0)
|
|
{
|
|
for(int i = 0; i < str.length(); i++)
|
|
{
|
|
char ch = str.charAt(i);
|
|
if(!Character.isWhitespace(ch))
|
|
{
|
|
return ch;
|
|
}
|
|
}
|
|
|
|
}
|
|
return '\0';
|
|
}
|
|
|
|
public static String replaceOnce(String template, String placeholder, String replacement)
|
|
{
|
|
if(template == null)
|
|
{
|
|
return template;
|
|
}
|
|
int loc = template.indexOf(placeholder);
|
|
if(loc < 0)
|
|
{
|
|
return template;
|
|
} else
|
|
{
|
|
return template.substring(0, loc) + replacement + template.substring(loc + placeholder.length());
|
|
}
|
|
}
|
|
|
|
public static String[] split(String seperators, String list)
|
|
{
|
|
return split(seperators, list, false);
|
|
}
|
|
|
|
public static String[] split(String seperators, String list, boolean include)
|
|
{
|
|
StringTokenizer tokens = new StringTokenizer(list, seperators, include);
|
|
String result[] = new String[tokens.countTokens()];
|
|
int i = 0;
|
|
while(tokens.hasMoreTokens())
|
|
{
|
|
result[i++] = tokens.nextToken();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static String unqualify(String qualifiedName)
|
|
{
|
|
int loc = qualifiedName.lastIndexOf(".");
|
|
return loc >= 0 ? qualifiedName.substring(qualifiedName.lastIndexOf(".") + 1) : qualifiedName;
|
|
}
|
|
|
|
public static String qualifier(String qualifiedName)
|
|
{
|
|
int loc = qualifiedName.lastIndexOf(".");
|
|
return loc >= 0 ? qualifiedName.substring(0, loc) : "";
|
|
}
|
|
|
|
public static String collapse(String name)
|
|
{
|
|
if(name == null)
|
|
{
|
|
return null;
|
|
}
|
|
int breakPoint = name.lastIndexOf('.');
|
|
if(breakPoint < 0)
|
|
{
|
|
return name;
|
|
} else
|
|
{
|
|
return (new StringBuilder()).append(collapseQualifier(name.substring(0, breakPoint), true)).append(name.substring(breakPoint)).toString();
|
|
}
|
|
}
|
|
|
|
public static String collapseQualifier(String qualifier, boolean includeDots)
|
|
{
|
|
StringTokenizer tokenizer = new StringTokenizer(qualifier, ".");
|
|
String collapsed;
|
|
for(collapsed = Character.toString(tokenizer.nextToken().charAt(0)); tokenizer.hasMoreTokens(); collapsed = (new StringBuilder()).append(collapsed).append(tokenizer.nextToken().charAt(0)).toString())
|
|
{
|
|
if(includeDots)
|
|
{
|
|
collapsed = (new StringBuilder()).append(collapsed).append('.').toString();
|
|
}
|
|
}
|
|
|
|
return collapsed;
|
|
}
|
|
|
|
public static String partiallyUnqualify(String name, String qualifierBase)
|
|
{
|
|
if(name == null || !name.startsWith(qualifierBase))
|
|
{
|
|
return name;
|
|
} else
|
|
{
|
|
return name.substring(qualifierBase.length() + 1);
|
|
}
|
|
}
|
|
|
|
public static String collapseQualifierBase(String name, String qualifierBase)
|
|
{
|
|
if(name == null || !name.startsWith(qualifierBase))
|
|
{
|
|
return collapse(name);
|
|
} else
|
|
{
|
|
return (new StringBuilder()).append(collapseQualifier(qualifierBase, true)).append(name.substring(qualifierBase.length())).toString();
|
|
}
|
|
}
|
|
|
|
public static String[] suffix(String columns[], String suffix)
|
|
{
|
|
if(suffix == null)
|
|
{
|
|
return columns;
|
|
}
|
|
String qualified[] = new String[columns.length];
|
|
for(int i = 0; i < columns.length; i++)
|
|
{
|
|
qualified[i] = suffix(columns[i], suffix);
|
|
}
|
|
|
|
return qualified;
|
|
}
|
|
|
|
private static String suffix(String name, String suffix)
|
|
{
|
|
return suffix != null ? (new StringBuilder()).append(name).append(suffix).toString() : name;
|
|
}
|
|
|
|
public static String root(String qualifiedName)
|
|
{
|
|
int loc = qualifiedName.indexOf(".");
|
|
return loc >= 0 ? qualifiedName.substring(0, loc) : qualifiedName;
|
|
}
|
|
|
|
public static String unroot(String qualifiedName)
|
|
{
|
|
int loc = qualifiedName.indexOf(".");
|
|
return loc >= 0 ? qualifiedName.substring(loc + 1, qualifiedName.length()) : qualifiedName;
|
|
}
|
|
|
|
public static boolean booleanValue(String tfString)
|
|
{
|
|
String trimmed = tfString.trim().toLowerCase();
|
|
return trimmed.equals("true") || trimmed.equals("t");
|
|
}
|
|
|
|
public static String toString(Object array[])
|
|
{
|
|
int len = array.length;
|
|
if(len == 0)
|
|
{
|
|
return "";
|
|
}
|
|
StringBuffer buf = new StringBuffer(len * 12);
|
|
for(int i = 0; i < len - 1; i++)
|
|
{
|
|
buf.append(array[i]).append(", ");
|
|
}
|
|
|
|
return buf.append(array[len - 1]).toString();
|
|
}
|
|
|
|
public static String[] multiply(String string, Iterator placeholders, Iterator replacements)
|
|
{
|
|
String result[];
|
|
for(result = (new String[] {
|
|
string
|
|
}); placeholders.hasNext(); result = multiply(result, (String)placeholders.next(), (String[])replacements.next())) { }
|
|
return result;
|
|
}
|
|
|
|
private static String[] multiply(String strings[], String placeholder, String replacements[])
|
|
{
|
|
String results[] = new String[replacements.length * strings.length];
|
|
int n = 0;
|
|
for(int i = 0; i < replacements.length; i++)
|
|
{
|
|
for(int j = 0; j < strings.length; j++)
|
|
{
|
|
results[n++] = replaceOnce(strings[j], placeholder, replacements[i]);
|
|
}
|
|
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
public static int countUnquoted(String string, char character)
|
|
{
|
|
if('\'' == character)
|
|
{
|
|
throw new IllegalArgumentException("Unquoted count of quotes is invalid");
|
|
}
|
|
if(string == null)
|
|
{
|
|
return 0;
|
|
}
|
|
int count = 0;
|
|
int stringLength = string.length();
|
|
boolean inQuote = false;
|
|
for(int indx = 0; indx < stringLength; indx++)
|
|
{
|
|
char c = string.charAt(indx);
|
|
if(inQuote)
|
|
{
|
|
if('\'' == c)
|
|
{
|
|
inQuote = false;
|
|
}
|
|
continue;
|
|
}
|
|
if('\'' == c)
|
|
{
|
|
inQuote = true;
|
|
continue;
|
|
}
|
|
if(c == character)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
public static int[] locateUnquoted(String string, char character)
|
|
{
|
|
if('\'' == character)
|
|
{
|
|
throw new IllegalArgumentException("Unquoted count of quotes is invalid");
|
|
}
|
|
if(string == null)
|
|
{
|
|
return new int[0];
|
|
}
|
|
ArrayList locations = new ArrayList(20);
|
|
int stringLength = string.length();
|
|
boolean inQuote = false;
|
|
for(int indx = 0; indx < stringLength; indx++)
|
|
{
|
|
char c = string.charAt(indx);
|
|
if(inQuote)
|
|
{
|
|
if('\'' == c)
|
|
{
|
|
inQuote = false;
|
|
}
|
|
continue;
|
|
}
|
|
if('\'' == c)
|
|
{
|
|
inQuote = true;
|
|
continue;
|
|
}
|
|
if(c == character)
|
|
{
|
|
locations.add(new Integer(indx));
|
|
}
|
|
}
|
|
|
|
return ArrayHelper.toIntArray(locations);
|
|
}
|
|
|
|
public static boolean isNotEmpty(String string)
|
|
{
|
|
return string != null && string.length() > 0;
|
|
}
|
|
|
|
public static boolean isEmpty(String string)
|
|
{
|
|
return string == null || string.length() == 0;
|
|
}
|
|
|
|
public static String qualify(String prefix, String name)
|
|
{
|
|
if(name == null || prefix == null)
|
|
{
|
|
throw new NullPointerException();
|
|
} else
|
|
{
|
|
return (new StringBuffer(prefix.length() + name.length() + 1)).append(prefix).append('.').append(name).toString();
|
|
}
|
|
}
|
|
|
|
public static String[] qualify(String prefix, String names[])
|
|
{
|
|
if(prefix == null)
|
|
{
|
|
return names;
|
|
}
|
|
int len = names.length;
|
|
String qualified[] = new String[len];
|
|
for(int i = 0; i < len; i++)
|
|
{
|
|
qualified[i] = qualify(prefix, names[i]);
|
|
}
|
|
|
|
return qualified;
|
|
}
|
|
|
|
public static int firstIndexOfChar(String sqlString, String string, int startindex)
|
|
{
|
|
int matchAt = -1;
|
|
for(int i = 0; i < string.length(); i++)
|
|
{
|
|
int curMatch = sqlString.indexOf(string.charAt(i), startindex);
|
|
if(curMatch < 0)
|
|
{
|
|
continue;
|
|
}
|
|
if(matchAt == -1)
|
|
{
|
|
matchAt = curMatch;
|
|
} else
|
|
{
|
|
matchAt = Math.min(matchAt, curMatch);
|
|
}
|
|
}
|
|
|
|
return matchAt;
|
|
}
|
|
|
|
public static String truncate(String string, int length)
|
|
{
|
|
if(string.length() <= length)
|
|
{
|
|
return string;
|
|
} else
|
|
{
|
|
return string.substring(0, length);
|
|
}
|
|
}
|
|
|
|
public static String generateAlias(String description)
|
|
{
|
|
return (new StringBuilder()).append(generateAliasRoot(description)).append('_').toString();
|
|
}
|
|
|
|
public static String generateAlias(String description, int unique)
|
|
{
|
|
return (new StringBuilder()).append(generateAliasRoot(description)).append(Integer.toString(unique)).append('_').toString();
|
|
}
|
|
|
|
private static String generateAliasRoot(String description)
|
|
{
|
|
String result = truncate(unqualifyEntityName(description), 10).toLowerCase().replace('/', '_').replace('$', '_');
|
|
result = cleanAlias(result);
|
|
if(Character.isDigit(result.charAt(result.length() - 1)))
|
|
{
|
|
return (new StringBuilder()).append(result).append("x").toString();
|
|
} else
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
private static String cleanAlias(String alias)
|
|
{
|
|
char chars[] = alias.toCharArray();
|
|
if(!Character.isLetter(chars[0]))
|
|
{
|
|
for(int i = 1; i < chars.length; i++)
|
|
{
|
|
if(Character.isLetter(chars[i]))
|
|
{
|
|
return alias.substring(i);
|
|
}
|
|
}
|
|
|
|
}
|
|
return alias;
|
|
}
|
|
|
|
public static String unqualifyEntityName(String entityName)
|
|
{
|
|
String result = unqualify(entityName);
|
|
int slashPos = result.indexOf('/');
|
|
if(slashPos > 0)
|
|
{
|
|
result = result.substring(0, slashPos - 1);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static String toUpperCase(String str)
|
|
{
|
|
return str != null ? str.toUpperCase() : null;
|
|
}
|
|
|
|
public static String toLowerCase(String str)
|
|
{
|
|
return str != null ? str.toLowerCase() : null;
|
|
}
|
|
|
|
public static String moveAndToBeginning(String filter)
|
|
{
|
|
if(filter.trim().length() > 0)
|
|
{
|
|
filter = (new StringBuilder()).append(filter).append(" and ").toString();
|
|
if(filter.startsWith(" and "))
|
|
{
|
|
filter = filter.substring(4);
|
|
}
|
|
}
|
|
return filter;
|
|
}
|
|
|
|
public static boolean isQuoted(String name)
|
|
{
|
|
return name != null && name.length() != 0 && name.charAt(0) == '`' && name.charAt(name.length() - 1) == '`';
|
|
}
|
|
|
|
public static String quote(String name)
|
|
{
|
|
if(name == null || name.length() == 0 || isQuoted(name))
|
|
{
|
|
return name;
|
|
} else
|
|
{
|
|
return (new StringBuffer(name.length() + 2)).append('`').append(name).append('`').toString();
|
|
}
|
|
}
|
|
|
|
public static String unquote(String name)
|
|
{
|
|
if(isQuoted(name))
|
|
{
|
|
return name.substring(1, name.length() - 1);
|
|
} else
|
|
{
|
|
return name;
|
|
}
|
|
}
|
|
|
|
public static boolean isQuoted(String name, Dialect dialect)
|
|
{
|
|
return name != null && name.length() != 0 && (name.charAt(0) == '`' && name.charAt(name.length() - 1) == '`' || name.charAt(0) == dialect.openQuote() && name.charAt(name.length() - 1) == dialect.closeQuote());
|
|
}
|
|
|
|
public static String unquote(String name, Dialect dialect)
|
|
{
|
|
if(isQuoted(name, dialect))
|
|
{
|
|
return name.substring(1, name.length() - 1);
|
|
} else
|
|
{
|
|
return name;
|
|
}
|
|
}
|
|
|
|
public static String[] unquote(String names[], Dialect dialect)
|
|
{
|
|
if(names == null)
|
|
{
|
|
return null;
|
|
}
|
|
String unquoted[] = new String[names.length];
|
|
for(int i = 0; i < names.length; i++)
|
|
{
|
|
unquoted[i] = unquote(names[i], dialect);
|
|
}
|
|
|
|
return unquoted;
|
|
}
|
|
}
|