* If there is no match, then either the first or last index is used. The first * or last index is used depending on whether the number is too low or too high. * The length of the format array must be the same as the length of the limits * array. *
*
*
* double[] limits = {1, 2, 3, 4, 5, 6, 7};
* String[] fmts = {"Sun", "Mon", "Tue", "Wed", "Thur", "Fri", "Sat"};
*
* double[] limits2 = {0, 1, ChoiceFormat.nextDouble(1)};
* String[] fmts2 = {"no files", "one file", "many files"};
*
*
* * ChoiceFormat.nextDouble(double) allows to get the double following the one * passed to the method. This is used to create half open intervals. *
* {@code ChoiceFormat} objects also may be converted to and from patterns. * The conversion can be done programmatically, as in the example above, or * by using a pattern like the following: *
* *** "1#Sun|2#Mon|3#Tue|4#Wed|5#Thur|6#Fri|7#Sat" * "0#are no files|1#is one file|1<are many files" ** *
* where: *
* The length of the {@code limits} and {@code formats} arrays must be the
* same.
*
* @param limits
* an array of doubles in ascending order. The lowest and highest
* possible values are negative and positive infinity.
* @param formats
* the strings associated with the ranges defined through {@code
* limits}. The lower bound of the associated range is at the
* same index as the string.
*/
public ChoiceFormat(double[] limits, String[] formats) {
setChoices(limits, formats);
}
/**
* Constructs a new {@code ChoiceFormat} with the strings and limits parsed
* from the specified pattern.
*
* @param template
* the pattern of strings and ranges.
* @throws IllegalArgumentException
* if an error occurs while parsing the pattern.
*/
public ChoiceFormat(String template) {
applyPattern(template);
}
/**
* Parses the pattern to determine new strings and ranges for this
* {@code ChoiceFormat}.
*
* @param template
* the pattern of strings and ranges.
* @throws IllegalArgumentException
* if an error occurs while parsing the pattern.
*/
public void applyPattern(String template) {
double[] limits = new double[5];
List
* If one of the format strings of this {@code ChoiceFormat} instance is
* found in {@code string} starting at {@code position.getIndex()} then
*
* If none of the format strings is found in {@code string} then
*
* The length of the {@code limits} and {@code formats} arrays must be the
* same.
*
* @param limits
* an array of doubles in ascending order. The lowest and highest
* possible values are negative and positive infinity.
* @param formats
* the strings associated with the ranges defined through {@code
* limits}. The lower bound of the associated range is at the
* same index as the string.
*/
public void setChoices(double[] limits, String[] formats) {
if (limits.length != formats.length) {
throw new IllegalArgumentException("limits.length != formats.length: " +
limits.length + " != " + formats.length);
}
choiceLimits = limits;
choiceFormats = formats;
}
private int skipWhitespace(String string, int index) {
int length = string.length();
while (index < length && Character.isWhitespace(string.charAt(index))) {
index++;
}
return index;
}
/**
* Returns the pattern of this {@code ChoiceFormat} which specifies the
* ranges and their associated strings.
*
* @return the pattern.
*/
public String toPattern() {
StringBuilder buffer = new StringBuilder();
for (int i = 0; i < choiceLimits.length; i++) {
if (i != 0) {
buffer.append('|');
}
final String previous = String.valueOf(previousDouble(choiceLimits[i]));
final String limit = String.valueOf(choiceLimits[i]);
// Hack to make the output of toPattern parseable by another ChoiceFormat.
// String.valueOf() will emit "Infinity", which isn't parseable by our NumberFormat
// instances.
//
// Ideally, we'd just use NumberFormat.format() to emit output (to be symmetric with
// our usage of NumberFormat.parse()) but it's hard set the right number of significant
// digits in order to output a format string that's equivalent to the original input.
if (Double.isInfinite(choiceLimits[i]) ||
Double.isInfinite(previousDouble(choiceLimits[i]))) {
if (choiceLimits[i] < 0) {
buffer.append("-\u221E");
buffer.append('<');
} else {
buffer.append('\u221E');
buffer.append('<');
}
} else if (previous.length() < limit.length()) {
// What the... i don't even.... sigh. This is trying to figure out whether the
// element was a "<" or a "#". The idea being that users will specify "reasonable"
// quantities and calling nextDouble will result in a "longer" number in most cases.
buffer.append(previous);
buffer.append('<');
} else {
buffer.append(limit);
buffer.append('#');
}
boolean quote = (choiceFormats[i].indexOf('|') != -1);
if (quote) {
buffer.append('\'');
}
buffer.append(choiceFormats[i]);
if (quote) {
buffer.append('\'');
}
}
return buffer.toString();
}
}
*
*
*
* @param string
* the source string to parse.
* @param position
* input/output parameter, specifies the start index in {@code
* string} from where to start parsing. See the Returns
* section for a description of the output values.
* @return a Double resulting from the parse, or Double.NaN if there is an
* error
*/
@Override
public Number parse(String string, ParsePosition position) {
int offset = position.getIndex();
for (int i = 0; i < choiceFormats.length; i++) {
if (string.startsWith(choiceFormats[i], offset)) {
position.setIndex(offset + choiceFormats[i].length());
return new Double(choiceLimits[i]);
}
}
position.setErrorIndex(offset);
return new Double(Double.NaN);
}
/**
* Equivalent to {@link Math#nextAfter(double, double)} with
* {@code direction == Double.NEGATIVE_INFINITY}.
*/
public static final double previousDouble(double value) {
return Math.nextAfter(value, Double.NEGATIVE_INFINITY);
}
/**
* Sets the double values and associated strings of this ChoiceFormat. When
* calling {@link #format(double, StringBuffer, FieldPosition) format} with
* a double value {@code d}, then the element {@code i} in {@code formats}
* is selected where {@code i} fulfills
* {@code limits[i] <= d < limits[i+1]}.
*