* . 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 is too low or too high. The length of the array of * formats must be the same as the length of the array of limits. * For example, *
* . {1,2,3,4,5,6,7},
* . {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}
* . {0, 1, ChoiceFormat.nextDouble(1)},
* . {"no files", "one file", "many files"}
*
* (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: *
* . double limits[] = {1,2,3,4,5,6,7};
* . UnicodeString monthNames[] = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"};
* . ChoiceFormat* form = new ChoiceFormat(limits, monthNames, 7);
* . ParsePosition* parse_pos = new ParsePosition();
* . // TODO Fix this ParsePosition stuff...
* . UnicodeString str;
* . for (double i = 0.0; i <= 8.0; ++i) {
* . status.index = 0;
* . cout << i << " -> " << form->format(i, str) << " -> "
* . << form->parse(form->format(i, str),parse_pos));
* . }
*
* Here is a more complex example, with a pattern format.
*
* . double filelimits[] = {0,1,2};
* . String filepart[] = {"are no files","is one file","are {2} files"};
* . ChoiceFormat* fileform = new ChoiceFormat(filelimits, filepart, 3);
* . Format testFormats[] = {fileform, null, &NumberFormat::getInstance()};
* . MessageFormat* pattform
* . = new MessageFormat("There {0} on {1}",testFormats);
* . Formattable testArgs[] = {0L, "ADisk", 0L};
* . UnicodeString str;
* . for (int i = 0; i < 4; ++i) {
* . testArgs[0] = Formattable((long)i);
* . testArgs[2] = testArgs[0];
* . cout << pattform->toPattern() << " -> ";
* . cout << pattform->format(testArgs, str);
* . }
*
* ChoiceFormat objects may be converted to and from patterns. The
* syntax of these patterns is [TODO fill in this section with detail].
* Here is an example of a ChoiceFormat pattern:
* * You can either do this programmatically, as in the above example, * or by using a pattern (see ChoiceFormat for more information) as in: *
* . "0#are no files|1#is one file|1<are many files" ** Here the notation is: *
* . <number> "#" Specifies a limit value. * . <number> "<" Specifies a limit of nextDouble(<number>). * . <number> ">" Specifies a limit of previousDouble(<number>). ** Each limit value is followed by a string, which is terminated by * a vertical bar character ("|"), except for the last string, which * is terminated by the end of the string. */ #ifdef NLS_MAC #pragma export on #endif class T_FORMAT_API ChoiceFormat: public NumberFormat { public: /** * Construct a new ChoiceFormat with the limits and the corresponding formats * based on the pattern. * * @param pattern Pattern used to construct object. * @param status Output param to receive success code. If the * pattern cannot be parsed, set to failure code. */ ChoiceFormat(const UnicodeString& newPattern, ErrorCode& status); /** * Construct a new ChoiceFormat with the given limits and formats. Copy * the limits and formats instead of adopting them. * * @param limits Array of limit values. * @param formats Array of formats. * @param count Size of 'limits' and 'formats' arrays. */ ChoiceFormat(const double* limits, const UnicodeString* formats, t_int32 count); /** * Copy constructor. */ ChoiceFormat(const ChoiceFormat&); /** * Assignment operator. */ const ChoiceFormat& operator=(const ChoiceFormat&); /** * Destructor. */ virtual ~ChoiceFormat(); /** * Clone this Format object polymorphically. The caller owns the * result and should delete it when done. */ virtual Format* clone() const; /** * Return true if the given Format objects are semantically equal. * Objects of different subclasses are considered unequal. */ virtual t_bool operator==(const Format& other) const; /** * Return true if the given Format objects are not semantically equal. * Objects of different subclasses are considered unequal. */ virtual t_bool operator!=(const Format& other) const; /** * Sets the pattern. * @param pattern The pattern to be applied. * @param status Output param set to success/failure code on * exit. If the pattern is invalid, this will be * set to a failure result. */ virtual void applyPattern(const UnicodeString& pattern, ErrorCode& status); /** * Gets the pattern. */ virtual UnicodeString& toPattern(UnicodeString &pattern) const; /** * Set the choices to be used in formatting. The arrays are adopted and * should not be deleted by the caller. * * @param limitsToAdopt Contains the top value that you want * parsed with that format,and should be in * ascending sorted order. When formatting X, * the choice will be the i, where limit[i] * <= X < limit[i+1]. * @param formatsToAdopt The format strings you want to use for each limit. * @param count The size of the above arrays. */ virtual void adoptChoices(double* limitsToAdopt, UnicodeString* formatsToAdopt, t_int32 count); /** * Set the choices to be used in formatting. * * @param limitsToCopy Contains the top value that you want * parsed with that format,and should be in * ascending sorted order. When formatting X, * the choice will be the i, where limit[i] * <= X < limit[i+1]. * @param formatsToCopy The format strings you want to use for each limit. * @param count The size of the above arrays. */ virtual void setChoices(const double* limitsToCopy, const UnicodeString* formatsToCopy, t_int32 count); /** * Get the limits passed in the constructor. * @return the limits. */ virtual const double* getLimits(t_int32& count) const; /** * Get the formats passed in the constructor. * @return the formats. */ virtual const UnicodeString* getFormats(t_int32& count) const; /** * Format a double or long number using this object's choices. * * @param number The value to be formatted. * @param toAppendTo The string to append the formatted string to. * This is an output parameter. * @param pos On input: an alignment field, if desired. * On output: the offsets of the alignment field. * @return A reference to 'toAppendTo'. */ virtual UnicodeString& format(double number, UnicodeString& toAppendTo, FieldPosition& pos) const; virtual UnicodeString& format(long number, UnicodeString& toAppendTo, FieldPosition& pos) const; virtual UnicodeString& format(const Formattable* objs, t_int32 cnt, UnicodeString& toAppendTo, FieldPosition& pos, ErrorCode& success) const; virtual UnicodeString& format(const Formattable& obj, UnicodeString& toAppendTo, FieldPosition& pos, ErrorCode& status) const; /** * Return a long if possible (e.g. within range LONG_MAX, * LONG_MAX], and with no decimals), otherwise a double. If * IntegerOnly is set, will stop at a decimal point (or equivalent; * e.g. for rational numbers "1 2/3", will stop after the 1). *
* If no object can be parsed, parsePosition is unchanged, and NULL is * returned. * * @param text The text to be parsed. * @param result Formattable to be set to the parse result. * If parse fails, return contents are undefined. * @param parsePosition The position to start parsing at on input. * On output, moved to after the last successfully * parse character. On parse failure, does not change. * @return A Formattable object of numeric type. The caller * owns this an must delete it. NULL on failure. * @see NumberFormat::isParseIntegerOnly */ virtual void parse(const UnicodeString& text, Formattable& result, ParsePosition& parsePosition) const; virtual void parse(const UnicodeString& text, Formattable& result, ErrorCode& status) const; public: /** * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. * This method is to implement a simple version of RTTI, since not all * C++ compilers support genuine RTTI. Polymorphic operator==() and * clone() methods call this method. * * @return The class ID for this object. All objects of a * given class have the same class ID. Objects of * other classes have different class IDs. */ virtual ClassID getDynamicClassID() const; /** * Return the class ID for this class. This is useful only for * comparing to a return value from getDynamicClassID(). For example: *
* . Base* polymorphic_pointer = createPolymorphicObject();
* . if (polymorphic_pointer->getDynamicClassID() ==
* . Derived::getStaticClassID()) ...
*
* @return The class ID for all objects of this class.
*/
static ClassID getStaticClassID() { return (ClassID)&fgClassID; }
/*
* Finds the least double greater than d (if positive == true),
* or the greatest double less than d (if positive == false).
* If NaN, returns same value.
* * Does not affect floating-point flags, */ static double nextDouble(double d, t_bool positive); /** * Finds the least double greater than d. * If NaN, returns same value. * Used to make half-open intervals. * @see ChoiceFormat::previousDouble */ static double nextDouble(double d ); /** * Finds the greatest double less than d. * If NaN, returns same value. * @see ChoiceFormat::nextDouble */ static double previousDouble(double d ); private: /** * Converts a string to a double value using a default NumberFormat object * which is static (shared by all ChoiceFormat instances). * @param string the string to be converted with. * @param status error code. * @return the converted double number. */ static double stod(const UnicodeString& string, ErrorCode& status); /** * Converts a double value to a string using a default NumberFormat object * which is static (shared by all ChoiceFormat instances). * @param value the double number to be converted with. * @param string the result string. * @param status error code. * @return the converted string. */ static UnicodeString& dtos(double value, UnicodeString& string, ErrorCode& status); static NumberFormat* fgNumberFormat; static char fgClassID; double* choiceLimits; UnicodeString* choiceFormats; t_bool* doubleFlags; // this array will soon disappear t_int32 count; }; #ifdef NLS_MAC #pragma export off #endif inline ClassID ChoiceFormat::getDynamicClassID() const { return ChoiceFormat::getStaticClassID(); } inline t_bool ChoiceFormat::operator!= (const Format& that) const { return !(*this == that); } inline double ChoiceFormat::nextDouble( double d ) { return ChoiceFormat::nextDouble( d, TRUE ); } inline double ChoiceFormat::previousDouble( double d ) { return ChoiceFormat::nextDouble( d, FALSE ); } #endif // _CHOICFMT //eof