i will be selected for value X if
* terminator[i] <= X < limit[i + 1]. If the value X is not
* included in any range, then either the first or last format will be
* used depending on whether the value X falls outside the range.
* * This sounds complicated, but that is because I did a poor job of * explaining it. Consider the following example: *
*
* terminators = { 1, ChoiceFormat.nextDouble(1) }
* formats = { "file", "files" }
*
*
* In this case if the actual number tested is one or less, then the word
* "file" is used as the format value. If the number tested is greater than
* one, then "files" is used. This allows plurals to be handled
* gracefully. Note the use of the method nextDouble. This
* method selects the next highest double number than its argument. This
* effectively makes any double greater than 1.0 cause the "files" string
* to be selected. (Note that all terminator values are specified as
* doubles.
*
* Note that in order for this class to work properly, the range terminator
* array must be sorted in ascending order and the format string array
* must be the same length as the terminator array.
*
* @author Tom Tromey ChoiceFormat that
* generates its range terminator and format string arrays from the
* specified pattern. This pattern is of the form
* "term#string|term#string...". For example "1#Sunday|2#Monday|#Tuesday".
* This is the same pattern type used by the applyPattern
* method.
*
* @param pattern The pattern of terminators and format strings.
*
* @exception IllegalArgumentException If the pattern is not valid
*/
public ChoiceFormat (String newPattern)
{
super ();
applyPattern (newPattern);
}
/**
* This method initializes a new instance of ChoiceFormat that
* will use the specified range terminators and format strings.
*
* @param choiceLimits The array of range terminators
* @param choiceFormats The array of format strings
*/
public ChoiceFormat (double[] choiceLimits, String[] choiceFormats)
{
super ();
setChoices (choiceLimits, choiceFormats);
}
/**
* This method tests this object for equality with the specified
* object. This will be true if and only if:
*
*
*
* @param obj The object to test for equality against.
*
* @return null.
* ChoiceFormat.
* true if the specified object is equal to
* this one, false otherwise.
*/
public boolean equals (Object obj)
{
if (! (obj instanceof ChoiceFormat))
return false;
ChoiceFormat cf = (ChoiceFormat) obj;
if (choiceLimits.length != cf.choiceLimits.length)
return false;
for (int i = choiceLimits.length - 1; i >= 0; --i)
{
if (choiceLimits[i] != cf.choiceLimits[i]
|| !choiceFormats[i].equals(cf.choiceFormats[i]))
return false;
}
return true;
}
/**
* This method appends the appropriate format string to the specified
* StringBuffer based on the supplied long
* argument.
*
* @param number The number used for determine (based on the range
* terminators) which format string to append.
* @param sb The StringBuffer to append the format string to.
* @param status Unused.
*
* @return The StringBuffer with the format string appended.
*/
public StringBuffer format (long num, StringBuffer appendBuf,
FieldPosition pos)
{
return format ((double) num, appendBuf, pos);
}
/**
* This method appends the appropriate format string to the specified
* StringBuffer based on the supplied double
* argument.
*
* @param number The number used for determine (based on the range
* terminators) which format string to append.
* @param sb The StringBuffer to append the format string to.
* @param status Unused.
*
* @return The StringBuffer with the format string appended.
*/
public StringBuffer format (double num, StringBuffer appendBuf,
FieldPosition pos)
{
if (choiceLimits.length == 0)
return appendBuf;
int index = 0;
if (! Double.isNaN(num) && num >= choiceLimits[0])
{
for (; index < choiceLimits.length - 1; ++index)
{
if (choiceLimits[index] <= num
&& index != choiceLimits.length - 2
&& num < choiceLimits[index + 1])
break;
}
}
return appendBuf.append(choiceFormats[index]);
}
/**
* This method returns the list of format strings in use.
*
* @return The list of format objects.
*/
public Object[] getFormats ()
{
return (Object[]) choiceFormats.clone();
}
/**
* This method returns the list of range terminators in use.
*
* @return The list of range terminators.
*/
public double[] getLimits ()
{
return (double[]) choiceLimits.clone();
}
/**
* This method returns a hash value for this object
*
* @return A hash value for this object.
*/
public int hashCode ()
{
int hash = 0;
for (int i = 0; i < choiceLimits.length; ++i)
{
long v = Double.doubleToLongBits(choiceLimits[i]);
hash ^= (v ^ (v >>> 32));
hash ^= choiceFormats[i].hashCode();
}
return hash;
}
/**
* This method returns the lowest possible double greater than the
* specified double. If the specified double value is equal to
* Double.NaN then that is the value returned.
*
* @param d The specified double
*
* @return The lowest double value greater than the specified double.
*/
public static final double nextDouble (double d)
{
return nextDouble (d, true);
}
/**
* This method returns a double that is either the next highest double
* or next lowest double compared to the specified double depending on the
* value of the passed boolean parameter. If the boolean parameter is
* true, then the lowest possible double greater than the
* specified double will be returned. Otherwise the highest possible
* double less than the specified double will be returned.
*
* @param d The specified double
* @param positive true to return the next highest
* double, false otherwise.
*
* @return The next highest or lowest double value.
*/
public static double nextDouble (double d, boolean next)
{
if (Double.isInfinite(d) || Double.isNaN(d))
return d;
long bits = Double.doubleToLongBits(d);
long mantMask = (1L << mantissaBits) - 1;
long mantissa = bits & mantMask;
long expMask = (1L << exponentBits) - 1;
long exponent = (bits >>> mantissaBits) & expMask;
if (next ^ (bits < 0)) // Increment magnitude
{
if (mantissa == (1L << mantissaBits) - 1)
{
mantissa = 0L;
exponent++;
// Check for absolute overflow.
if (exponent >= (1L << mantissaBits))
return (bits > 0) ? Double.POSITIVE_INFINITY
: Double.NEGATIVE_INFINITY;
}
else
mantissa++;
}
else // Decrement magnitude
{
if (exponent == 0L && mantissa == 0L)
{
// The only case where there is a change of sign
return next ? Double.MIN_VALUE : -Double.MIN_VALUE;
}
else
{
if (mantissa == 0L)
{
mantissa = (1L << mantissaBits) - 1;
exponent--;
}
else
mantissa--;
}
}
long result = bits < 0 ? 1 : 0;
result = (result << exponentBits) | exponent;
result = (result << mantissaBits) | mantissa;
return Double.longBitsToDouble(result);
}
/**
* I'm not sure what this method is really supposed to do, as it is
* not documented.
*/
public Number parse (String sourceStr, ParsePosition pos)
{
int index = pos.getIndex();
for (int i = 0; i < choiceLimits.length; ++i)
{
if (sourceStr.startsWith(choiceFormats[i], index))
{
pos.setIndex(index + choiceFormats[i].length());
return new Double (choiceLimits[i]);
}
}
pos.setErrorIndex(index);
return new Double (Double.NaN);
}
/**
* This method returns the highest possible double less than the
* specified double. If the specified double value is equal to
* Double.NaN then that is the value returned.
*
* @param d The specified double
*
* @return The highest double value less than the specified double.
*/
public static final double previousDouble (double d)
{
return nextDouble (d, false);
}
/**
* This method sets new range terminators and format strings for this
* object.
*
* @param choiceLimits The new range terminators
* @param choiceFormats The new choice formats
*/
public void setChoices (double[] choiceLimits, String[] choiceFormats)
{
if (choiceLimits == null || choiceFormats == null)
throw new NullPointerException ();
if (choiceLimits.length != choiceFormats.length)
throw new IllegalArgumentException ();
this.choiceFormats = (String[]) choiceFormats.clone();
this.choiceLimits = (double[]) choiceLimits.clone();
}
private final void quoteString (StringBuffer dest, String text)
{
int max = text.length();
for (int i = 0; i < max; ++i)
{
char c = text.charAt(i);
if (c == '\'')
{
dest.append(c);
dest.append(c);
}
else if (c == '#' || c == '|' || c == '\u2064' || c == '<')
{
dest.append('\'');
dest.append(c);
dest.append('\'');
}
else
dest.append(c);
}
}
/**
* This method returns the range terminator list and format string list
* as a String suitable for using with the
* applyPattern method.
*
* @return A pattern string for this object
*/
public String toPattern ()
{
StringBuffer result = new StringBuffer ();
for (int i = 0; i < choiceLimits.length; ++i)
{
result.append(choiceLimits[i]);
result.append('#');
quoteString (result, choiceFormats[i]);
}
return result.toString();
}
/**
* This is the list of format strings. Note that this variable is
* specified by the serialization spec of this class.
*/
private String[] choiceFormats;
/**
* This is the list of range terminator values. Note that this variable is
* specified by the serialization spec of this class.
*/
private double[] choiceLimits;
// Number of mantissa bits in double.
private static final int mantissaBits = 52;
// Number of exponent bits in a double.
private static final int exponentBits = 11;
private static final long serialVersionUID = 1795184449645032964L;
}