java.text.ChoiceFormat Maven / Gradle / Ivy
Show all versions of qbicc-rt-java.base Show documentation
/*
* Copyright (c) 1996, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
* (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
*
* The original version of this source code and documentation is copyrighted
* and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
* materials are provided under terms of a License Agreement between Taligent
* and Sun. This technology is protected by multiple US and International
* patents. This notice and attribution to Taligent may not be removed.
* Taligent is a registered trademark of Taligent, Inc.
*
*/
package java.text;
import java.io.InvalidObjectException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Arrays;
/**
* A {@code ChoiceFormat} allows you to attach a format to a range of numbers.
* It is generally used in a {@code MessageFormat} for handling plurals.
* The choice is specified with an ascending list of doubles, where each item
* specifies a half-open interval up to the next item:
*
*
* X matches j if and only if limit[j] ≤ X < limit[j+1]
*
*
* If there is no match, then either the first or last index is used, depending
* on whether the number (X) is too low or too high. If the limit array is not
* in ascending order, the results of formatting will be incorrect. ChoiceFormat
* also accepts \u221E as equivalent to infinity(INF).
*
*
* Note:
* {@code ChoiceFormat} differs from the other {@code Format}
* classes in that you create a {@code ChoiceFormat} object with a
* constructor (not with a {@code getInstance} style factory
* method). The factory methods aren't necessary because {@code ChoiceFormat}
* doesn't require any complex setup for a given locale. In fact,
* {@code ChoiceFormat} doesn't implement any locale specific behavior.
*
*
* When creating a {@code ChoiceFormat}, you must specify an array of formats
* and an array of limits. The length of these arrays must be the same.
* For example,
*
* -
* limits = {1,2,3,4,5,6,7}
* formats = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}
* -
* limits = {0, 1, ChoiceFormat.nextDouble(1)}
* formats = {"no files", "one file", "many files"}
* ({@code nextDouble} can be used to get the next higher double, to
* make the half-open interval.)
*
*
*
* Here is a simple example that shows formatting and parsing:
*
* {@code
* double[] limits = {1,2,3,4,5,6,7};
* String[] dayOfWeekNames = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"};
* ChoiceFormat form = new ChoiceFormat(limits, dayOfWeekNames);
* ParsePosition status = new ParsePosition(0);
* for (double i = 0.0; i <= 8.0; ++i) {
* status.setIndex(0);
* System.out.println(i + " -> " + form.format(i) + " -> "
* + form.parse(form.format(i),status));
* }
* }
*
* Here is a more complex example, with a pattern format:
*
* {@code
* double[] filelimits = {0,1,2};
* String[] filepart = {"are no files","is one file","are {2} files"};
* ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
* Format[] testFormats = {fileform, null, NumberFormat.getInstance()};
* MessageFormat pattform = new MessageFormat("There {0} on {1}");
* pattform.setFormats(testFormats);
* Object[] testArgs = {null, "ADisk", null};
* for (int i = 0; i < 4; ++i) {
* testArgs[0] = new Integer(i);
* testArgs[2] = testArgs[0];
* System.out.println(pattform.format(testArgs));
* }
* }
*
*
* Specifying a pattern for ChoiceFormat objects is fairly straightforward.
* For example:
*
* {@code
* ChoiceFormat fmt = new ChoiceFormat(
* "-1#is negative| 0#is zero or fraction | 1#is one |1.0
*
* And the output result would be like the following:
*
* {@code
* Format with -INF : is negative
* Format with -1.0 : is negative
* Format with 0 : is zero or fraction
* Format with 0.9 : is zero or fraction
* Format with 1.0 : is one
* Format with 1.5 : is 1+
* Format with 2 : is two
* Format with 2.1 : is more than 2.
* Format with NaN : is negative
* Format with +INF : is more than 2.
* }
*
*
* Synchronization
*
*
* Choice formats are not synchronized.
* It is recommended to create separate format instances for each thread.
* If multiple threads access a format concurrently, it must be synchronized
* externally.
*
*
* @see DecimalFormat
* @see MessageFormat
* @author Mark Davis
* @since 1.1
*/
public class ChoiceFormat extends NumberFormat {
// Proclaim serial compatibility with 1.1 FCS
@java.io.Serial
private static final long serialVersionUID = 1795184449645032964L;
/**
* Sets the pattern.
* @param newPattern See the class description.
* @throws NullPointerException if {@code newPattern}
* is {@code null}
*/
public void applyPattern(String newPattern) {
StringBuffer[] segments = new StringBuffer[2];
for (int i = 0; i < segments.length; ++i) {
segments[i] = new StringBuffer();
}
double[] newChoiceLimits = new double[30];
String[] newChoiceFormats = new String[30];
int count = 0;
int part = 0;
double startValue = 0;
double oldStartValue = Double.NaN;
boolean inQuote = false;
for (int i = 0; i < newPattern.length(); ++i) {
char ch = newPattern.charAt(i);
if (ch=='\'') {
// Check for "''" indicating a literal quote
if ((i+1)= 0
|| text.indexOf('#') >= 0
|| text.indexOf('\u2264') >= 0
|| text.indexOf('|') >= 0;
if (needQuote) result.append('\'');
if (text.indexOf('\'') < 0) result.append(text);
else {
for (int j=0; j= choiceLimits[i])) {
// same as number < choiceLimits, except catchs NaN
break;
}
}
--i;
if (i < 0) i = 0;
// return either a formatted number, or a string
return toAppendTo.append(choiceFormats[i]);
}
/**
* Parses a Number from the input text.
* @param text the source text.
* @param status an input-output parameter. On input, the
* status.index field indicates the first character of the
* source text that should be parsed. On exit, if no error
* occurred, status.index is set to the first unparsed character
* in the source text. On exit, if an error did occur,
* status.index is unchanged and status.errorIndex is set to the
* first index of the character that caused the parse to fail.
* @return A Number representing the value of the number parsed.
* @throws NullPointerException if {@code status} is {@code null}
* or if {@code text} is {@code null} and the list of
* choice strings is not empty.
*/
public Number parse(String text, ParsePosition status) {
// find the best number (defined as the one with the longest parse)
int start = status.index;
int furthest = start;
double bestNumber = Double.NaN;
double tempNumber = 0.0;
for (int i = 0; i < choiceFormats.length; ++i) {
String tempString = choiceFormats[i];
if (text.regionMatches(start, tempString, 0, tempString.length())) {
status.index = start + tempString.length();
tempNumber = choiceLimits[i];
if (status.index > furthest) {
furthest = status.index;
bestNumber = tempNumber;
if (furthest == text.length()) break;
}
}
}
status.index = furthest;
if (status.index == start) {
status.errorIndex = furthest;
}
return Double.valueOf(bestNumber);
}
/**
* Finds the least double greater than {@code d}.
* If {@code NaN}, returns same value.
* Used to make half-open intervals.
*
* @implNote This is equivalent to calling
* {@link Math#nextUp(double) Math.nextUp(d)}
*
* @param d the reference value
* @return the least double value greather than {@code d}
* @see #previousDouble
*/
public static final double nextDouble (double d) {
return Math.nextUp(d);
}
/**
* Finds the greatest double less than {@code d}.
* If {@code NaN}, returns same value.
*
* @implNote This is equivalent to calling
* {@link Math#nextDown(double) Math.nextDown(d)}
*
* @param d the reference value
* @return the greatest double value less than {@code d}
* @see #nextDouble
*/
public static final double previousDouble (double d) {
return Math.nextDown(d);
}
/**
* Overrides Cloneable
*/
public Object clone()
{
ChoiceFormat other = (ChoiceFormat) super.clone();
// for primitives or immutables, shallow clone is enough
other.choiceLimits = choiceLimits.clone();
other.choiceFormats = choiceFormats.clone();
return other;
}
/**
* Generates a hash code for the message format object.
*/
public int hashCode() {
int result = choiceLimits.length;
if (choiceFormats.length > 0) {
// enough for reasonable distribution
result ^= choiceFormats[choiceFormats.length-1].hashCode();
}
return result;
}
/**
* Equality comparison between two
*/
public boolean equals(Object obj) {
if (obj == null) return false;
if (this == obj) // quick check
return true;
if (getClass() != obj.getClass())
return false;
ChoiceFormat other = (ChoiceFormat) obj;
return (Arrays.equals(choiceLimits, other.choiceLimits)
&& Arrays.equals(choiceFormats, other.choiceFormats));
}
/**
* After reading an object from the input stream, do a simple verification
* to maintain class invariants.
* @throws InvalidObjectException if the objects read from the stream is invalid.
*/
@java.io.Serial
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
if (choiceLimits.length != choiceFormats.length) {
throw new InvalidObjectException(
"limits and format arrays of different length.");
}
}
// ===============privates===========================
/**
* A list of lower bounds for the choices. The formatter will return
* {@code choiceFormats[i]} if the number being formatted is greater than or equal to
* {@code choiceLimits[i]} and less than {@code choiceLimits[i+1]}.
* @serial
*/
private double[] choiceLimits;
/**
* A list of choice strings. The formatter will return
* {@code choiceFormats[i]} if the number being formatted is greater than or equal to
* {@code choiceLimits[i]} and less than {@code choiceLimits[i+1]}.
* @serial
*/
private String[] choiceFormats;
/**
* Finds the least double greater than {@code d} (if {@code positive} is
* {@code true}), or the greatest double less than {@code d} (if
* {@code positive} is {@code false}).
* If {@code NaN}, returns same value.
*
* @implNote This is equivalent to calling
* {@code positive ? Math.nextUp(d) : Math.nextDown(d)}
*
* @param d the reference value
* @param positive {@code true} if the least double is desired;
* {@code false} otherwise
* @return the least or greater double value
*/
public static double nextDouble (double d, boolean positive) {
return positive ? Math.nextUp(d) : Math.nextDown(d);
}
private static double[] doubleArraySize(double[] array) {
int oldSize = array.length;
double[] newArray = new double[oldSize * 2];
System.arraycopy(array, 0, newArray, 0, oldSize);
return newArray;
}
private String[] doubleArraySize(String[] array) {
int oldSize = array.length;
String[] newArray = new String[oldSize * 2];
System.arraycopy(array, 0, newArray, 0, oldSize);
return newArray;
}
}