TransformerImpl transformer, long[] list, int contextNode)
throws TransformerException
{
String numStr;
FastStringBuffer formattedNumber = StringBufferPool.get();
try
{
int nNumbers = list.length, numberWidth = 1;
char numberType = '1';
String formatToken, lastSepString = null, formatTokenString = null;
// If a seperator hasn't been specified, then use "."
// as a default separator.
// For instance: [2][1][5] with a format value of "1 "
// should format to "2.1.5 " (I think).
// Otherwise, use the seperator specified in the format string.
// For instance: [2][1][5] with a format value of "01-001. "
// should format to "02-001-005 ".
String lastSep = ".";
boolean isFirstToken = true; // true if first token
String formatValue =
(null != m_format_avt)
? m_format_avt.evaluate(
transformer.getXPathContext(), contextNode, this) : null;
if (null == formatValue)
formatValue = "1";
NumberFormatStringTokenizer formatTokenizer =
new NumberFormatStringTokenizer(formatValue);
// int sepCount = 0; // keep track of seperators
// Loop through all the numbers in the list.
for (int i = 0; i < nNumbers; i++)
{
// Loop to the next digit, letter, or separator.
if (formatTokenizer.hasMoreTokens())
{
formatToken = formatTokenizer.nextToken();
// If the first character of this token is a character or digit, then
// it is a number format directive.
if (Character.isLetterOrDigit(
formatToken.charAt(formatToken.length() - 1)))
{
numberWidth = formatToken.length();
numberType = formatToken.charAt(numberWidth - 1);
}
// If there is a number format directive ahead,
// then append the formatToken.
else if (formatTokenizer.isLetterOrDigitAhead())
{
formatTokenString = formatToken;
// Append the formatToken string...
// For instance [2][1][5] with a format value of "1--1. "
// should format to "2--1--5. " (I guess).
while (formatTokenizer.nextIsSep())
{
formatToken = formatTokenizer.nextToken();
formatTokenString += formatToken;
}
// Record this separator, so it can be used as the
// next separator, if the next is the last.
// For instance: [2][1][5] with a format value of "1-1 "
// should format to "2-1-5 ".
if (!isFirstToken)
lastSep = formatTokenString;
// Since we know the next is a number or digit, we get it now.
formatToken = formatTokenizer.nextToken();
numberWidth = formatToken.length();
numberType = formatToken.charAt(numberWidth - 1);
}
else // only separators left
{
// Set up the string for the trailing characters after
// the last number is formatted (i.e. after the loop).
lastSepString = formatToken;
// And append any remaining characters to the lastSepString.
while (formatTokenizer.hasMoreTokens())
{
formatToken = formatTokenizer.nextToken();
lastSepString += formatToken;
}
} // else
} // end if(formatTokenizer.hasMoreTokens())
// if this is the first token and there was a prefix
// append the prefix else, append the separator
// For instance, [2][1][5] with a format value of "(1-1.) "
// should format to "(2-1-5.) " (I guess).
if (null != formatTokenString && isFirstToken)
{
formattedNumber.append(formatTokenString);
}
else if (null != lastSep &&!isFirstToken)
formattedNumber.append(lastSep);
getFormattedNumber(transformer, contextNode, numberType, numberWidth,
list[i], formattedNumber);
isFirstToken = false; // After the first pass, this should be false
} // end for loop
// Check to see if we finished up the format string...
// Skip past all remaining letters or digits
while (formatTokenizer.isLetterOrDigitAhead())
{
formatTokenizer.nextToken();
}
if (lastSepString != null)
formattedNumber.append(lastSepString);
while (formatTokenizer.hasMoreTokens())
{
formatToken = formatTokenizer.nextToken();
formattedNumber.append(formatToken);
}
numStr = formattedNumber.toString();
}
finally
{
StringBufferPool.free(formattedNumber);
}