package prefuse.util;
import java.awt.FontMetrics;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.io.StringReader;
import java.io.StringWriter;
import java.lang.reflect.Array;
import java.util.Hashtable;
/**
* Library of utility routines pertaining to Strings.
*
* @author <a href="http://jheer.org">jeffrey heer</a>
*/
public class StringLib {
private StringLib() {
// prevent instantiation
}
/**
* Given an array object, create a String showing the contents
* of the array using a "[a[0], a[1], ..., a[a.length-1]]" format.
* @param a the array object
* @return the array string
*/
public static final String getArrayString(Object a) {
StringBuffer sbuf = new StringBuffer();
sbuf.append('[');
int size = Array.getLength(a);
for ( int i=0; i<size; ++i ) {
if ( i>0 ) sbuf.append(", ");
sbuf.append(Array.get(a, i));
}
sbuf.append(']');
return sbuf.toString();
}
/**
* Format the given number as a String, including the given number of
* decimal places.
* @param number the number to format
* @param decimalPlaces the number of decimal places to include
* @return the formatted String
*/
public static String formatNumber(double number, int decimalPlaces) {
String s = String.valueOf(number);
int idx1 = s.indexOf('.');
if ( idx1 == -1 ) {
return s;
} else {
int idx2 = s.indexOf('E');
int dp = decimalPlaces + (idx2>=0 ? 0 : 1);
String t = s.substring(0, Math.min(idx1+dp, s.length()));
if ( idx2 >= 0 )
t += s.substring(idx2);
return t;
}
}
/**
* Capitalize all letters preceded by whitespace, and lower case
* all other letters.
* @param s the String to capitalize
* @return the capitalized string
*/
public static String capitalizeFirstOnly(String s) {
if ( s == null )
return null;
if ( s.length() == 0 )
return s;
StringBuffer sbuf = new StringBuffer();
char c = s.charAt(0);
sbuf.append(Character.toUpperCase(c));
boolean space = Character.isWhitespace(c);
for ( int i=1; i<s.length(); ++i ) {
c = s.charAt(i);
if ( Character.isWhitespace(c) ) {
space = true;
} else if ( space ) {
c = Character.toUpperCase(c);
space = false;
} else {
c = Character.toLowerCase(c);
}
sbuf.append(c);
}
return sbuf.toString();
}
/**
* Get the stack trace of the given Throwable as a String.
* @param t the Throwable
* @return the stack trace of the Throwable
*/
public static String getStackTrace(Throwable t) {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
t.printStackTrace(pw);
pw.close();
return sw.toString();
}
// ------------------------------------------------------------------------
// Abbreviation Methods
private static final String SUFFIX = "suffix";
private static final String PREFIX = "prefix";
private static Hashtable prefixSuffixT = new Hashtable();
static {
prefixSuffixT.put( "mr", PREFIX );
prefixSuffixT.put( "mr.", PREFIX );
prefixSuffixT.put( "dr", PREFIX );
prefixSuffixT.put( "dr.", PREFIX );
prefixSuffixT.put( "lt", PREFIX );
prefixSuffixT.put( "lt.", PREFIX );
prefixSuffixT.put( "gen", PREFIX );
prefixSuffixT.put( "gen.", PREFIX );
prefixSuffixT.put( "sgt", PREFIX );
prefixSuffixT.put( "sgt.", PREFIX );
prefixSuffixT.put( "cmdr", PREFIX );
prefixSuffixT.put( "cmdr.", PREFIX );
prefixSuffixT.put( "cpt", PREFIX );
prefixSuffixT.put( "cpt.", PREFIX );
prefixSuffixT.put( "ii", SUFFIX );
prefixSuffixT.put( "iii", SUFFIX );
prefixSuffixT.put( "iv", SUFFIX );
prefixSuffixT.put( "jr", SUFFIX );
prefixSuffixT.put( "jr.", SUFFIX );
prefixSuffixT.put( "sr", SUFFIX );
prefixSuffixT.put( "sr.", SUFFIX );
}
/**
* Abbreviate a String by simply truncating it.
* @param str the String to abbreviate
* @param fm the FontMetrics for measuring the String length
* @param width the maximum string width, in pixels
* @return an abbreviated String
*/
public static String abbreviate(String str, FontMetrics fm, int width) {
int lastblank = 0, nchars = 0, cumx = 0;
while ( cumx < width && nchars < str.length() ) {
if ( Character.isWhitespace(str.charAt(nchars)) ) {
lastblank = nchars;
}
cumx += fm.charWidth(str.charAt(nchars));
nchars++;
}
if ( nchars < str.length() && lastblank > 0 ) { nchars = lastblank; }
return ( nchars > 0 ? str.substring(0, nchars) : str );
}
/**
* Abbreviate a String as a given name.
* @param str the String to abbreviate
* @param fm the FontMetrics for measuring the String length
* @param width the maximum string width, in pixels
* @return an abbreviated String
*/
public static String abbreviateName(String str, FontMetrics fm, int width)
{
if (fm.stringWidth(str) > width) str = abbreviateName(str, false);
if (fm.stringWidth(str) > width) str = abbreviateName(str, true);
return str;
}
/**
* String abbreviation helper method for name strings.
* @param inString the String to abbreviate
* @param lastOnly true to include only the last name, false otherwise
* @return an abbreviated name
*/
private static String abbreviateName(String inString, boolean lastOnly) {
StringReader in = new StringReader(inString);
StreamTokenizer p = new StreamTokenizer(in);
p.wordChars('&', '&');
p.wordChars('@', '@');
p.wordChars(':', ':');
p.ordinaryChar(',');
p.ordinaryChar('-');
int c;
String lastNameHold = null;
String lastInitialHold = null;
StringBuffer outString = new StringBuffer();
try {
out:
while (true) {
c = p.nextToken();
switch (c) {
case StreamTokenizer.TT_EOF:
break out;
case StreamTokenizer.TT_EOL:
System.err.println("warning: unexpected EOL token"); break;
case StreamTokenizer.TT_NUMBER:
break;
case ',':
break out;
case StreamTokenizer.TT_WORD:
if (p.sval.endsWith(":")) outString.append(p.sval + " ");
else if (prefixSuffixT.get(p.sval.toLowerCase()) == null) {
if (!lastOnly) {
if (lastInitialHold != null) outString.append(lastInitialHold);
lastInitialHold = p.sval.substring(0,1)+". ";
}
lastNameHold = p.sval;
}
break;
default:
break;
}
}
outString.append(lastNameHold);
} catch (IOException e) {
e.printStackTrace();
}
return outString.toString();
}
} // end of class StringLib