1 /*
2 * Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /*
27 * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
28 * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
29 *
30 * The original version of this source code and documentation is copyrighted
31 * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
32 * materials are provided under terms of a License Agreement between Taligent
33 * and Sun. This technology is protected by multiple US and International
34 * patents. This notice and attribution to Taligent may not be removed.
35 * Taligent is a registered trademark of Taligent, Inc.
36 *
37 */
38
39 package java.text;
40
41 import java.io.InvalidObjectException;
42 import java.io.IOException;
43 import java.io.ObjectInputStream;
44 import java.util.Arrays;
45
46 /**
47 * A <code>ChoiceFormat</code> allows you to attach a format to a range of numbers.
48 * It is generally used in a <code>MessageFormat</code> for handling plurals.
49 * The choice is specified with an ascending list of doubles, where each item
50 * specifies a half-open interval up to the next item:
51 * <blockquote>
52 * <pre>
53 * X matches j if and only if limit[j] ≤ X < limit[j+1]
54 * </pre>
55 * </blockquote>
56 * If there is no match, then either the first or last index is used, depending
57 * on whether the number (X) is too low or too high. If the limit array is not
58 * in ascending order, the results of formatting will be incorrect. ChoiceFormat
59 * also accepts <code>\u221E</code> as equivalent to infinity(INF).
60 *
61 * <p>
62 * <strong>Note:</strong>
63 * <code>ChoiceFormat</code> differs from the other <code>Format</code>
64 * classes in that you create a <code>ChoiceFormat</code> object with a
65 * constructor (not with a <code>getInstance</code> style factory
66 * method). The factory methods aren't necessary because <code>ChoiceFormat</code>
67 * doesn't require any complex setup for a given locale. In fact,
68 * <code>ChoiceFormat</code> doesn't implement any locale specific behavior.
69 *
70 * <p>
71 * When creating a <code>ChoiceFormat</code>, you must specify an array of formats
72 * and an array of limits. The length of these arrays must be the same.
73 * For example,
74 * <ul>
75 * <li>
76 * <em>limits</em> = {1,2,3,4,5,6,7}<br>
77 * <em>formats</em> = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}
78 * <li>
79 * <em>limits</em> = {0, 1, ChoiceFormat.nextDouble(1)}<br>
80 * <em>formats</em> = {"no files", "one file", "many files"}<br>
81 * (<code>nextDouble</code> can be used to get the next higher double, to
82 * make the half-open interval.)
83 * </ul>
84 *
85 * <p>
86 * Here is a simple example that shows formatting and parsing:
87 * <blockquote>
88 * <pre>{@code
89 * double[] limits = {1,2,3,4,5,6,7};
90 * String[] dayOfWeekNames = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"};
91 * ChoiceFormat form = new ChoiceFormat(limits, dayOfWeekNames);
92 * ParsePosition status = new ParsePosition(0);
93 * for (double i = 0.0; i <= 8.0; ++i) {
94 * status.setIndex(0);
95 * System.out.println(i + " -> " + form.format(i) + " -> "
96 * + form.parse(form.format(i),status));
97 * }
98 * }</pre>
99 * </blockquote>
100 * Here is a more complex example, with a pattern format:
101 * <blockquote>
102 * <pre>{@code
103 * double[] filelimits = {0,1,2};
104 * String[] filepart = {"are no files","is one file","are {2} files"};
105 * ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
106 * Format[] testFormats = {fileform, null, NumberFormat.getInstance()};
107 * MessageFormat pattform = new MessageFormat("There {0} on {1}");
108 * pattform.setFormats(testFormats);
109 * Object[] testArgs = {null, "ADisk", null};
110 * for (int i = 0; i < 4; ++i) {
111 * testArgs[0] = new Integer(i);
112 * testArgs[2] = testArgs[0];
113 * System.out.println(pattform.format(testArgs));
114 * }
115 * }</pre>
116 * </blockquote>
117 * <p>
118 * Specifying a pattern for ChoiceFormat objects is fairly straightforward.
119 * For example:
120 * <blockquote>
121 * <pre>{@code
122 * ChoiceFormat fmt = new ChoiceFormat(
123 * "-1#is negative| 0#is zero or fraction | 1#is one |1.0<is 1+ |2#is two |2<is more than 2.");
124 * System.out.println("Formatter Pattern : " + fmt.toPattern());
125 *
126 * System.out.println("Format with -INF : " + fmt.format(Double.NEGATIVE_INFINITY));
127 * System.out.println("Format with -1.0 : " + fmt.format(-1.0));
128 * System.out.println("Format with 0 : " + fmt.format(0));
129 * System.out.println("Format with 0.9 : " + fmt.format(0.9));
130 * System.out.println("Format with 1.0 : " + fmt.format(1));
131 * System.out.println("Format with 1.5 : " + fmt.format(1.5));
132 * System.out.println("Format with 2 : " + fmt.format(2));
133 * System.out.println("Format with 2.1 : " + fmt.format(2.1));
134 * System.out.println("Format with NaN : " + fmt.format(Double.NaN));
135 * System.out.println("Format with +INF : " + fmt.format(Double.POSITIVE_INFINITY));
136 * }</pre>
137 * </blockquote>
138 * And the output result would be like the following:
139 * <blockquote>
140 * <pre>{@code
141 * Format with -INF : is negative
142 * Format with -1.0 : is negative
143 * Format with 0 : is zero or fraction
144 * Format with 0.9 : is zero or fraction
145 * Format with 1.0 : is one
146 * Format with 1.5 : is 1+
147 * Format with 2 : is two
148 * Format with 2.1 : is more than 2.
149 * Format with NaN : is negative
150 * Format with +INF : is more than 2.
151 * }</pre>
152 * </blockquote>
153 *
154 * <h3><a id="synchronization">Synchronization</a></h3>
155 *
156 * <p>
157 * Choice formats are not synchronized.
158 * It is recommended to create separate format instances for each thread.
159 * If multiple threads access a format concurrently, it must be synchronized
160 * externally.
161 *
162 *
163 * @see DecimalFormat
164 * @see MessageFormat
165 * @author Mark Davis
166 * @since 1.1
167 */
168 public class ChoiceFormat extends NumberFormat {
169
170 // Proclaim serial compatibility with 1.1 FCS
171 private static final long serialVersionUID = 1795184449645032964L;
172
173 /**
174 * Sets the pattern.
175 * @param newPattern See the class description.
176 * @exception NullPointerException if {@code newPattern}
177 * is {@code null}
178 */
179 public void applyPattern(String newPattern) {
180 StringBuffer[] segments = new StringBuffer[2];
181 for (int i = 0; i < segments.length; ++i) {
182 segments[i] = new StringBuffer();
183 }
184 double[] newChoiceLimits = new double[30];
185 String[] newChoiceFormats = new String[30];
186 int count = 0;
187 int part = 0;
188 double startValue = 0;
189 double oldStartValue = Double.NaN;
190 boolean inQuote = false;
191 for (int i = 0; i < newPattern.length(); ++i) {
192 char ch = newPattern.charAt(i);
193 if (ch=='\'') {
194 // Check for "''" indicating a literal quote
195 if ((i+1)<newPattern.length() && newPattern.charAt(i+1)==ch) {
196 segments[part].append(ch);
197 ++i;
198 } else {
199 inQuote = !inQuote;
200 }
201 } else if (inQuote) {
202 segments[part].append(ch);
203 } else if (ch == '<' || ch == '#' || ch == '\u2264') {
204 if (segments[0].length() == 0) {
205 throw new IllegalArgumentException("Each interval must"
206 + " contain a number before a format");
207 }
208
209 String tempBuffer = segments[0].toString();
210 if (tempBuffer.equals("\u221E")) {
211 startValue = Double.POSITIVE_INFINITY;
212 } else if (tempBuffer.equals("-\u221E")) {
213 startValue = Double.NEGATIVE_INFINITY;
214 } else {
215 startValue = Double.valueOf(tempBuffer);
216 }
217
218 if (ch == '<' && startValue != Double.POSITIVE_INFINITY &&
219 startValue != Double.NEGATIVE_INFINITY) {
220 startValue = nextDouble(startValue);
221 }
222 if (startValue <= oldStartValue) {
223 throw new IllegalArgumentException("Incorrect order of"
224 + " intervals, must be in ascending order");
225 }
226 segments[0].setLength(0);
227 part = 1;
228 } else if (ch == '|') {
229 if (count == newChoiceLimits.length) {
230 newChoiceLimits = doubleArraySize(newChoiceLimits);
231 newChoiceFormats = doubleArraySize(newChoiceFormats);
232 }
233 newChoiceLimits[count] = startValue;
234 newChoiceFormats[count] = segments[1].toString();
235 ++count;
236 oldStartValue = startValue;
237 segments[1].setLength(0);
238 part = 0;
239 } else {
240 segments[part].append(ch);
241 }
242 }
243 // clean up last one
244 if (part == 1) {
245 if (count == newChoiceLimits.length) {
246 newChoiceLimits = doubleArraySize(newChoiceLimits);
247 newChoiceFormats = doubleArraySize(newChoiceFormats);
248 }
249 newChoiceLimits[count] = startValue;
250 newChoiceFormats[count] = segments[1].toString();
251 ++count;
252 }
253 choiceLimits = new double[count];
254 System.arraycopy(newChoiceLimits, 0, choiceLimits, 0, count);
255 choiceFormats = new String[count];
256 System.arraycopy(newChoiceFormats, 0, choiceFormats, 0, count);
257 }
258
259 /**
260 * Gets the pattern.
261 *
262 * @return the pattern string
263 */
264 public String toPattern() {
265 StringBuilder result = new StringBuilder();
266 for (int i = 0; i < choiceLimits.length; ++i) {
267 if (i != 0) {
268 result.append('|');
269 }
270 // choose based upon which has less precision
271 // approximate that by choosing the closest one to an integer.
272 // could do better, but it's not worth it.
273 double less = previousDouble(choiceLimits[i]);
274 double tryLessOrEqual = Math.abs(Math.IEEEremainder(choiceLimits[i], 1.0d));
275 double tryLess = Math.abs(Math.IEEEremainder(less, 1.0d));
276
277 if (tryLessOrEqual < tryLess) {
278 result.append(choiceLimits[i]);
279 result.append('#');
280 } else {
281 if (choiceLimits[i] == Double.POSITIVE_INFINITY) {
282 result.append("\u221E");
283 } else if (choiceLimits[i] == Double.NEGATIVE_INFINITY) {
284 result.append("-\u221E");
285 } else {
286 result.append(less);
287 }
288 result.append('<');
289 }
290 // Append choiceFormats[i], using quotes if there are special characters.
291 // Single quotes themselves must be escaped in either case.
292 String text = choiceFormats[i];
293 boolean needQuote = text.indexOf('<') >= 0
294 || text.indexOf('#') >= 0
295 || text.indexOf('\u2264') >= 0
296 || text.indexOf('|') >= 0;
297 if (needQuote) result.append('\'');
298 if (text.indexOf('\'') < 0) result.append(text);
299 else {
300 for (int j=0; j<text.length(); ++j) {
301 char c = text.charAt(j);
302 result.append(c);
303 if (c == '\'') result.append(c);
304 }
305 }
306 if (needQuote) result.append('\'');
307 }
308 return result.toString();
309 }
310
311 /**
312 * Constructs with limits and corresponding formats based on the pattern.
313 *
314 * @param newPattern the new pattern string
315 * @exception NullPointerExcpetion if {@code newPattern} is
316 * {@code null}
317 * @see #applyPattern
318 */
319 public ChoiceFormat(String newPattern) {
320 applyPattern(newPattern);
321 }
322
323 /**
324 * Constructs with the limits and the corresponding formats.
325 *
326 * @param limits limits in ascending order
327 * @param formats corresponding format strings
328 * @exception NullPointerException if {@code limits} or {@code formats}
329 * is {@code null}
330 * @see #setChoices
331 */
332 public ChoiceFormat(double[] limits, String[] formats) {
333 setChoices(limits, formats);
334 }
335
336 /**
337 * Set the choices to be used in formatting.
338 * @param limits contains the top value that you want
339 * parsed with that format, and should be in ascending sorted order. When
340 * formatting X, the choice will be the i, where
341 * limit[i] ≤ X {@literal <} limit[i+1].
342 * If the limit array is not in ascending order, the results of formatting
343 * will be incorrect.
344 * @param formats are the formats you want to use for each limit.
345 * They can be either Format objects or Strings.
346 * When formatting with object Y,
347 * if the object is a NumberFormat, then ((NumberFormat) Y).format(X)
348 * is called. Otherwise Y.toString() is called.
349 * @exception NullPointerException if {@code limits} or
350 * {@code formats} is {@code null}
351 */
352 public void setChoices(double[] limits, String formats[]) {
353 if (limits.length != formats.length) {
354 throw new IllegalArgumentException(
355 "Array and limit arrays must be of the same length.");
356 }
357 choiceLimits = Arrays.copyOf(limits, limits.length);
358 choiceFormats = Arrays.copyOf(formats, formats.length);
359 }
360
361 /**
362 * Get the limits passed in the constructor.
363 * @return the limits.
364 */
365 public double[] getLimits() {
366 double[] newLimits = Arrays.copyOf(choiceLimits, choiceLimits.length);
367 return newLimits;
368 }
369
370 /**
371 * Get the formats passed in the constructor.
372 * @return the formats.
373 */
374 public Object[] getFormats() {
375 Object[] newFormats = Arrays.copyOf(choiceFormats, choiceFormats.length);
376 return newFormats;
377 }
378
379 // Overrides
380
381 /**
382 * Specialization of format. This method really calls
383 * <code>format(double, StringBuffer, FieldPosition)</code>
384 * thus the range of longs that are supported is only equal to
385 * the range that can be stored by double. This will never be
386 * a practical limitation.
387 */
388 public StringBuffer format(long number, StringBuffer toAppendTo,
389 FieldPosition status) {
390 return format((double)number, toAppendTo, status);
391 }
392
393 /**
394 * Returns pattern with formatted double.
395 * @param number number to be formatted and substituted.
396 * @param toAppendTo where text is appended.
397 * @param status ignore no useful status is returned.
398 * @exception NullPointerException if {@code toAppendTo}
399 * is {@code null}
400 */
401 public StringBuffer format(double number, StringBuffer toAppendTo,
402 FieldPosition status) {
403 // find the number
404 int i;
405 for (i = 0; i < choiceLimits.length; ++i) {
406 if (!(number >= choiceLimits[i])) {
407 // same as number < choiceLimits, except catchs NaN
408 break;
409 }
410 }
411 --i;
412 if (i < 0) i = 0;
413 // return either a formatted number, or a string
414 return toAppendTo.append(choiceFormats[i]);
415 }
416
417 /**
418 * Parses a Number from the input text.
419 * @param text the source text.
420 * @param status an input-output parameter. On input, the
421 * status.index field indicates the first character of the
422 * source text that should be parsed. On exit, if no error
423 * occurred, status.index is set to the first unparsed character
424 * in the source text. On exit, if an error did occur,
425 * status.index is unchanged and status.errorIndex is set to the
426 * first index of the character that caused the parse to fail.
427 * @return A Number representing the value of the number parsed.
428 * @exception NullPointerException if {@code status} is {@code null}
429 * or if {@code text} is {@code null} and the list of
430 * choice strings is not empty.
431 */
432 public Number parse(String text, ParsePosition status) {
433 // find the best number (defined as the one with the longest parse)
434 int start = status.index;
435 int furthest = start;
436 double bestNumber = Double.NaN;
437 double tempNumber = 0.0;
438 for (int i = 0; i < choiceFormats.length; ++i) {
439 String tempString = choiceFormats[i];
440 if (text.regionMatches(start, tempString, 0, tempString.length())) {
441 status.index = start + tempString.length();
442 tempNumber = choiceLimits[i];
443 if (status.index > furthest) {
444 furthest = status.index;
445 bestNumber = tempNumber;
446 if (furthest == text.length()) break;
447 }
448 }
449 }
450 status.index = furthest;
451 if (status.index == start) {
452 status.errorIndex = furthest;
453 }
454 return Double.valueOf(bestNumber);
455 }
456
457 /**
458 * Finds the least double greater than {@code d}.
459 * If {@code NaN}, returns same value.
460 * <p>Used to make half-open intervals.
461 *
462 * @param d the reference value
463 * @return the least double value greather than {@code d}
464 * @see #previousDouble
465 */
466 public static final double nextDouble (double d) {
467 return nextDouble(d,true);
468 }
469
470 /**
471 * Finds the greatest double less than {@code d}.
472 * If {@code NaN}, returns same value.
473 *
474 * @param d the reference value
475 * @return the greatest double value less than {@code d}
476 * @see #nextDouble
477 */
478 public static final double previousDouble (double d) {
479 return nextDouble(d,false);
480 }
481
482 /**
483 * Overrides Cloneable
484 */
485 public Object clone()
486 {
487 ChoiceFormat other = (ChoiceFormat) super.clone();
488 // for primitives or immutables, shallow clone is enough
489 other.choiceLimits = choiceLimits.clone();
490 other.choiceFormats = choiceFormats.clone();
491 return other;
492 }
493
494 /**
495 * Generates a hash code for the message format object.
496 */
497 public int hashCode() {
498 int result = choiceLimits.length;
499 if (choiceFormats.length > 0) {
500 // enough for reasonable distribution
501 result ^= choiceFormats[choiceFormats.length-1].hashCode();
502 }
503 return result;
504 }
505
506 /**
507 * Equality comparison between two
508 */
509 public boolean equals(Object obj) {
510 if (obj == null) return false;
511 if (this == obj) // quick check
512 return true;
513 if (getClass() != obj.getClass())
514 return false;
515 ChoiceFormat other = (ChoiceFormat) obj;
516 return (Arrays.equals(choiceLimits, other.choiceLimits)
517 && Arrays.equals(choiceFormats, other.choiceFormats));
518 }
519
520 /**
521 * After reading an object from the input stream, do a simple verification
522 * to maintain class invariants.
523 * @throws InvalidObjectException if the objects read from the stream is invalid.
524 */
525 private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
526 in.defaultReadObject();
527 if (choiceLimits.length != choiceFormats.length) {
528 throw new InvalidObjectException(
529 "limits and format arrays of different length.");
530 }
531 }
532
533 // ===============privates===========================
534
535 /**
536 * A list of lower bounds for the choices. The formatter will return
537 * <code>choiceFormats[i]</code> if the number being formatted is greater than or equal to
538 * <code>choiceLimits[i]</code> and less than <code>choiceLimits[i+1]</code>.
539 * @serial
540 */
541 private double[] choiceLimits;
542
543 /**
544 * A list of choice strings. The formatter will return
545 * <code>choiceFormats[i]</code> if the number being formatted is greater than or equal to
546 * <code>choiceLimits[i]</code> and less than <code>choiceLimits[i+1]</code>.
547 * @serial
548 */
549 private String[] choiceFormats;
550
551 /*
552 static final long SIGN = 0x8000000000000000L;
553 static final long EXPONENT = 0x7FF0000000000000L;
554 static final long SIGNIFICAND = 0x000FFFFFFFFFFFFFL;
555
556 private static double nextDouble (double d, boolean positive) {
557 if (Double.isNaN(d) || Double.isInfinite(d)) {
558 return d;
559 }
560 long bits = Double.doubleToLongBits(d);
561 long significand = bits & SIGNIFICAND;
562 if (bits < 0) {
563 significand |= (SIGN | EXPONENT);
564 }
565 long exponent = bits & EXPONENT;
566 if (positive) {
567 significand += 1;
568 // FIXME fix overflow & underflow
569 } else {
570 significand -= 1;
571 // FIXME fix overflow & underflow
572 }
573 bits = exponent | (significand & ~EXPONENT);
574 return Double.longBitsToDouble(bits);
575 }
576 */
577
578 static final long SIGN = 0x8000000000000000L;
579 static final long EXPONENT = 0x7FF0000000000000L;
580 static final long POSITIVEINFINITY = 0x7FF0000000000000L;
581
582 /**
583 * Finds the least double greater than {@code d} (if {@code positive} is
584 * {@code true}), or the greatest double less than {@code d} (if
585 * {@code positive} is {@code false}).
586 * If {@code NaN}, returns same value.
587 *
588 * Does not affect floating-point flags,
589 * provided these member functions do not:
590 * Double.longBitsToDouble(long)
591 * Double.doubleToLongBits(double)
592 * Double.isNaN(double)
593 *
594 * @param d the reference value
595 * @param positive {@code true} if the least double is desired;
596 * {@code false} otherwise
597 * @return the least or greater double value
598 */
599 public static double nextDouble (double d, boolean positive) {
600
601 /* filter out NaN's */
602 if (Double.isNaN(d)) {
603 return d;
604 }
605
606 /* zero's are also a special case */
607 if (d == 0.0) {
608 double smallestPositiveDouble = Double.longBitsToDouble(1L);
609 if (positive) {
610 return smallestPositiveDouble;
611 } else {
612 return -smallestPositiveDouble;
613 }
614 }
615
616 /* if entering here, d is a nonzero value */
617
618 /* hold all bits in a long for later use */
619 long bits = Double.doubleToLongBits(d);
620
621 /* strip off the sign bit */
622 long magnitude = bits & ~SIGN;
623
624 /* if next double away from zero, increase magnitude */
625 if ((bits > 0) == positive) {
626 if (magnitude != POSITIVEINFINITY) {
627 magnitude += 1;
628 }
629 }
630 /* else decrease magnitude */
631 else {
632 magnitude -= 1;
633 }
634
635 /* restore sign bit and return */
636 long signbit = bits & SIGN;
637 return Double.longBitsToDouble (magnitude | signbit);
638 }
639
640 private static double[] doubleArraySize(double[] array) {
641 int oldSize = array.length;
642 double[] newArray = new double[oldSize * 2];
643 System.arraycopy(array, 0, newArray, 0, oldSize);
644 return newArray;
645 }
646
647 private String[] doubleArraySize(String[] array) {
648 int oldSize = array.length;
649 String[] newArray = new String[oldSize * 2];
650 System.arraycopy(array, 0, newArray, 0, oldSize);
651 return newArray;
652 }
653
654 }