UCHAR_ID_START and continue with characters in
+ * UCHARID_CONTINUE, in particular they do not start with a digit.
+ * If named arguments are used, {@link #usesNamedArguments()} will return true.
+ *
+ * The other new methods supporting named arguments are
+ * {@link #getFormatNames(UErrorCode& status)},
+ * {@link #getFormat(const UnicodeString& formatName, UErrorCode& status)}
+ * {@link #setFormat(const UnicodeString& formatName, const Format& format, UErrorCode& status)},
+ * {@link #adoptFormat(const UnicodeString& formatName, Format* formatToAdopt, UErrorCode& status)},
+ * {@link #format(const Formattable* arguments, const UnicodeString *argumentNames, int32_t cnt, UnicodeString& appendTo, FieldPosition& status, int32_t recursionProtection, UErrorCode& success)},
+ * {@link #format(const UnicodeString* argumentNames, const Formattable* arguments, int32_t count, UnicodeString& appendTo,UErrorCode& status)}.
+ * These methods are all compatible with patterns that do not used named arguments--
+ * in these cases the keys in the input or output use UnicodeStrings
+ * that name the argument indices, e.g. "0", "1", "2"... etc.
+ *
+ * When named arguments are used, certain methods on MessageFormat that take or + * return arrays do not perform any action, since it is not possible to + * identify positions in an array using a name. UErrorCode is set to + * U_ARGUMENT_TYPE_MISMATCH if there is a status/success field in the method. + * These methods are + * {@link #adoptFormats(Format** newFormats, int32_t count)}, + * {@link #setFormats(const Format** newFormats,int32_t count)}, + * {@link #adoptFormat(int32_t n, Format *newFormat)}, + * {@link #getFormats(int32_t& cnt)}, + * {@link #format(const Formattable* source,int32_t cnt,UnicodeString& appendTo, FieldPosition& ignore, UErrorCode& success)}, + * {@link #format(const UnicodeString& pattern,const Formattable* arguments,int32_t cnt,UnicodeString& appendTo,UErrorCode& success)}, + * {@link #format(const Formattable& source, UnicodeString& appendTo,FieldPosition& ignore, UErrorCode& success)}, + * {@link #format(const Formattable* arguments, int32_t cnt, UnicodeString& appendTo, FieldPosition& status, int32_t recursionProtection,UErrorCode& success)}, + * {@link #parse(const UnicodeString& source, ParsePosition& pos,int32_t& count)}, + * {@link #parse(const UnicodeString& source, int32_t& cnt, UErrorCode& status)} + *
+ * *
* During parsing, an input string is matched against the string * template of the MessageFormat to produce an array of Formattable @@ -147,7 +184,7 @@ class DateFormat; * \code * messageFormatPattern := string ( "{" messageFormatElement "}" string )* * - * messageFormatElement := argumentIndex { "," elementFormat } + * messageFormatElement := argumentIndex | argumentName { "," elementFormat } * * elementFormat := "time" { "," datetimeStyle } * | "date" { "," datetimeStyle } @@ -166,6 +203,8 @@ class DateFormat; * | numberFormatPattern * * choiceStyle := choiceFormatPattern + * + * pluralStyle := pluralFormatPattern * \endcode * * If there is no elementFormat, then the argument must be a string, @@ -427,7 +466,7 @@ public: * @param newFormats the new format to be set. * @param cnt the size of the array. */ - virtual void setFormats(const Format** newFormats,int32_t cnt); + virtual void setFormats(const Format** newFormats, int32_t cnt); /** @@ -453,6 +492,62 @@ public: */ virtual void setFormat(int32_t formatNumber, const Format& format); + /** + * Gets format names. This function returns formatNames in StringEnumerations + * which can be used with getFormat() and setFormat() to export formattable + * array from current MessageFormat to another. It is caller's resposibility + * to delete the returned formatNames. + * @param status output param set to success/failure code. + * @draft ICU 4.0 + */ + virtual StringEnumeration* getFormatNames(UErrorCode& status); + + /** + * Gets subformat pointer for given format name. + * This function supports both named and numbered + * arguments-- if numbered, the formatName is the + * corresponding UnicodeStrings (e.g. "0", "1", "2"...). + * The returned Format object should not be deleted by the caller, + * nor should the ponter of other object . The pointer and its + * contents remain valid only until the next call to any method + * of this class is made with this object. + * @param status output param set to success/failure code. + * @draft ICU 4.0 + */ + virtual Format* getFormat(const UnicodeString& formatName, UErrorCode& status); + + /** + * Sets one subformat for given format name. + * See the class description about format name. + * This function supports both named and numbered + * arguments-- if numbered, the formatName is the + * corresponding UnicodeStrings (e.g. "0", "1", "2"...). + * If there is no matched formatName or wrong type, + * the item will be ignored. + * @param formatName Name of the subformat. + * @param format the format to be set. + * @param status output param set to success/failure code. + * @draft ICU 4.0 + */ + virtual void setFormat(const UnicodeString& formatName, const Format& format, UErrorCode& status); + + /** + * Sets one subformat for given format name. + * See the class description about format name. + * This function supports both named and numbered + * arguments-- if numbered, the formatName is the + * corresponding UnicodeStrings (e.g. "0", "1", "2"...). + * If there is no matched formatName or wrong type, + * the item will be ignored. + * The caller should not delete the Format object after this call. + * @param formatName Name of the subformat. + * @param format Format to be adopted. + * @param status output param set to success/failure code. + * @draft ICU 4.0 + */ + virtual void adoptFormat(const UnicodeString& formatName, Format* formatToAdopt, UErrorCode& status); + + /** * Gets an array of subformats of this object. The returned array * should not be deleted by the caller, nor should the pointers @@ -500,11 +595,11 @@ public: * @return Reference to 'appendTo' parameter. * @stable ICU 2.0 */ - static UnicodeString& format( const UnicodeString& pattern, - const Formattable* arguments, - int32_t count, - UnicodeString& appendTo, - UErrorCode& status); + static UnicodeString& format(const UnicodeString& pattern, + const Formattable* arguments, + int32_t count, + UnicodeString& appendTo, + UErrorCode& status); /** * Formats the given array of arguments into a user-readable @@ -545,7 +640,31 @@ public: UnicodeString& format(const Formattable& obj, UnicodeString& appendTo, UErrorCode& status) const; + + /** + * Formats the given array of arguments into a user-defined argument name + * array. This function supports both named and numbered + * arguments-- if numbered, the formatName is the + * corresponding UnicodeStrings (e.g. "0", "1", "2"...). + * + * @param argumentNames argument name array + * @param arguments An array of objects to be formatted. + * @param count The number of elements of 'argumentNames' and + * arguments. The number of argumentNames and arguments + * must be the same. + * @param appendTo Output parameter to receive result. + * Result is appended to existing contents. + * @param status Input/output error code. If the + * pattern cannot be parsed, set to failure code. + * @return Reference to 'appendTo' parameter. + * @stable ICU 4.0 + */ + UnicodeString& format(const UnicodeString* argumentNames, + const Formattable* arguments, + int32_t count, + UnicodeString& appendTo, + UErrorCode& status) const; /** * Parses the given string into an array of output arguments. * @@ -569,9 +688,12 @@ public: * @param source String to be parsed. * @param count Output param to receive size of returned array. * @param status Input/output error code. If the - * pattern cannot be parsed, set to failure code. + * pattern cannot be parsed, set to failure code. + * If the MessageFormat is named argument, the status is + * set to U_ARGUMENT_TYPE_MISMATCH. * @return an array of parsed arguments. The caller owns both - * the array and its contents. + * the array and its contents. Return NULL if status is not U_ZERO_ERROR. + * * @stable ICU 2.0 */ virtual Formattable* parse( const UnicodeString& source, @@ -615,7 +737,16 @@ public: */ static UnicodeString autoQuoteApostrophe(const UnicodeString& pattern, UErrorCode& status); - + + /** + * Returns true if this MessageFormat uses named arguments, + * and false otherwise. See class description. + * + * @return true if named arguments are used. + * @draft ICU 4.0 + */ + UBool usesNamedArguments() const; + /** * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. * This method is to implement a simple version of RTTI, since not all @@ -648,6 +779,8 @@ private: UnicodeString fPattern; Format** formatAliases; // see getFormats int32_t formatAliasesCapacity; + UProperty idStart; + UProperty idContinue; MessageFormat(); // default constructor not implemented @@ -671,8 +804,13 @@ private: /** * @internal */ - int32_t arg; // 0-based argument number - + // TODO (claireho) or save the number to argName and use itos to convert to number.=> we need this number + int32_t argNum; // 0-based argument number + /** + * @internal + */ + UnicodeString* argName; // argument name or number + /** * Clone that.format and assign it to this.format * Do NOT delete this.format @@ -681,7 +819,8 @@ private: Subformat& operator=(const Subformat& that) { format = that.format ? that.format->clone() : NULL; offset = that.offset; - arg = that.arg; + argNum = that.argNum; + argName = (that.argNum==-1) ? new UnicodeString(*that.argName): NULL; return *this; } @@ -691,7 +830,9 @@ private: UBool operator==(const Subformat& that) const { // Do cheap comparisons first return offset == that.offset && - arg == that.arg && + argNum == that.argNum && + ((argName == that.argName) || + (*argName == *that.argName)) && ((format == that.format) || // handles NULL (*format == *that.format)); } @@ -724,6 +865,12 @@ private: int32_t argTypeCount; int32_t argTypeCapacity; + /** + * Is true iff all argument names are non-negative numbers. + * + */ + UBool isArgNumeric; + // Variable-size array management UBool allocateSubformats(int32_t capacity); UBool allocateArgTypes(int32_t capacity); @@ -776,6 +923,14 @@ private: FieldPosition& status, int32_t recursionProtection, UErrorCode& success) const; + + UnicodeString& format( const Formattable* arguments, + const UnicodeString *argumentNames, + int32_t cnt, + UnicodeString& appendTo, + FieldPosition& status, + int32_t recursionProtection, + UErrorCode& success) const; void makeFormat(int32_t offsetNumber, UnicodeString* segments, @@ -810,7 +965,14 @@ private: listCount = argTypeCount; return argTypes; } - + + /** + * Returns FALSE if the argument name is not legal. + * @param argName argument name. + * @return TRUE if the argument name is legal, otherwise return FALSE. + */ + UBool isLegalArgName(const UnicodeString& argName) const; + friend class MessageFormatAdapter; // getFormatTypeList() access }; diff --git a/icu4c/source/i18n/unicode/plurfmt.h b/icu4c/source/i18n/unicode/plurfmt.h new file mode 100644 index 00000000000..101412f6476 --- /dev/null +++ b/icu4c/source/i18n/unicode/plurfmt.h @@ -0,0 +1,507 @@ +/* +******************************************************************************* +* Copyright (C) 2007, International Business Machines Corporation and +* others. All Rights Reserved. +******************************************************************************* +* + +* File PLURFMT.H +* +* Modification History:* +* Date Name Description +* +******************************************************************************** +*/ + +#ifndef PLURFMT +#define PLURFMT + +/** + * \file + * \brief C++ API: PluralFormat object + */ + +#if !UCONFIG_NO_FORMATTING + +#include "unicode/numfmt.h" +#include "unicode/plurfmt.h" +#include "unicode/plurrule.h" +#include "unicode/utypes.h" + +U_NAMESPACE_BEGIN + +class Hashtable; +class PluralRules; +class NumberFormat; +/** + *
+ * PluralFormat supports the creation of internationalized
+ * messages with plural inflection. It is based on plural
+ * selection, i.e. the caller specifies messages for each
+ * plural case that can appear in the users language and the
+ * PluralFormat selects the appropriate message based on
+ * the number.
+ *
+ * Different languages have different ways to inflect
+ * plurals. Creating internationalized messages that include plural
+ * forms is only feasible when the framework is able to handle plural
+ * forms of all languages correctly. ChoiceFormat
+ * doesn't handle this well, because it attaches a number interval to
+ * each message and selects the message whose interval contains a
+ * given number. This can only handle a finite number of
+ * intervals. But in some languages, like Polish, one plural case
+ * applies to infinitely many intervals (e.g., paucal applies to
+ * numbers ending with 2, 3, or 4 except those ending with 12, 13, or
+ * 14). Thus ChoiceFormat is not adequate.
+ *
+ * PluralFormat deals with this by breaking the problem
+ * into two parts:
+ *
PluralRules that can define more complex
+ * conditions for a plural case than just a single interval. These plural
+ * rules define both what plural cases exist in a language, and to
+ * which numbers these cases apply.
+ * PluralFormat
+ * This discussion assumes that you use PluralFormat with
+ * a predefined set of plural rules. You can create one using one of
+ * the constructors that takes a locale object. To
+ * specify the message pattern, you can either pass it to the
+ * constructor or set it explicitly using the
+ * applyPattern() method. The format()
+ * method takes a number object and selects the message of the
+ * matching plural case. This message will be returned.
+ *
+ * The pattern text defines the message output for each plural case of the
+ * used locale. The pattern is a sequence of
+ * caseKeyword{message} clauses, separated by white
+ * space characters. Each clause assigns the message message
+ * to the plural case identified by caseKeyword.
+ *
+ * You always have to define a message text for the default plural case
+ * "other" which is contained in every rule set. If the plural
+ * rules of the PluralFormat object do not contain a plural case
+ * identified by caseKeyword, U_DEFAULT_KEYWORD_MISSING
+ * will be set to status.
+ * If you do not specify a message text for a particular plural case, the
+ * message text of the plural case "other" gets assigned to this
+ * plural case. If you specify more than one message for the same plural case,
+ * U_DUPLICATE_KEYWORD will be set to status.
+ *
+ * Spaces between caseKeyword and
+ * message will be ignored; spaces within
+ * message will be preserved.
+ *
+ * The message text for a particular plural case may contain other message
+ * format patterns. PluralFormat preserves these so that you
+ * can use the strings produced by PluralFormat with other
+ * formatters. If you are using PluralFormat inside a
+ * MessageFormat pattern, MessageFormat will
+ * automatically evaluate the resulting format pattern.
+ * Thus, curly braces ({, }) are only allowed
+ * in message texts to define a nested format pattern.
+ * The pound sign (#) will be interpreted as the number placeholder
+ * in the message text, if it is not contained in curly braces (to preserve
+ * NumberFormat patterns). PluralFormat will
+ * replace each of those pound signs by the number passed to the
+ * format() method. It will be formatted using a
+ * NumberFormat for the PluralFormat's locale. If you
+ * need special number formatting, you have to explicitly specify a
+ * NumberFormat for the PluralFormat to use.
+ *
+ * UErrorCode status = U_ZERO_ERROR;
+ * MessageFormat* msgFmt = new MessageFormat(UnicodeString("{0, plural,
+ * one{0, number, C''est #,##0.0# fichier} other {Ce sont # fichiers}} dans la liste."),
+ * Locale("fr"), status);
+ * if (U_FAILURE(status)) {
+ * return;
+ * }
+ * Formattable args1[] = {(int32_t)0};
+ * Formattable args2[] = {(int32_t)3};
+ * FieldPosition ignore(FieldPosition::DONT_CARE);
+ * UnicodeString result;
+ * msgFmt->format(args1, 1, result, ignore, status);
+ * cout << result << endl;
+ * result.remove();
+ * msgFmt->format(args2, 1, result, ignore, status);
+ * cout << result << endl;
+ *
+ * Produces the output:C'est 0,0 fichier dans la liste.Ce sont 3 fichiers dans la liste."
+ *
+ * Note:
+ * Currently PluralFormat
+ * does not make use of quotes like MessageFormat.
+ * If you use plural format strings with MessageFormat and want
+ * to use a quote sign "'", you have to write "''".
+ * MessageFormat unquotes this pattern and passes the unquoted
+ * pattern to PluralFormat. It's a bit trickier if you use
+ * nested formats that do quoting. In the example above, we wanted to insert
+ * "'" in the number format pattern. Since
+ * NumberFormat supports quotes, we had to insert
+ * "''". But since MessageFormat unquotes the
+ * pattern before it gets passed to PluralFormat, we have to
+ * double these quotes, i.e. write "''''".
+ *
If you need to use PluralFormat with custom rules, you can
+ * create a PluralRules object and pass it to
+ * PluralFormat's constructor. If you also specify a locale in this
+ * constructor, this locale will be used to format the number in the message
+ * texts.
+ *
+ * For more information about PluralRules, see
+ * {@link PluralRules}.
+ *
PluralFormat for the default locale.
+ * This locale will be used to get the set of plural rules and for standard
+ * number formatting.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ PluralFormat(UErrorCode& status);
+
+ /**
+ * Creates a new PluralFormat for a given locale.
+ * @param locale the PluralFormat will be configured with
+ * rules for this locale. This locale will also be used for
+ * standard number formatting.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ PluralFormat(const Locale& locale, UErrorCode& status);
+
+ /**
+ * Creates a new PluralFormat for a given set of rules.
+ * The standard number formatting will be done using the default locale.
+ * @param rules defines the behavior of the PluralFormat
+ * object.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ PluralFormat(const PluralRules& rules, UErrorCode& status);
+
+ /**
+ * Creates a new PluralFormat for a given set of rules.
+ * The standard number formatting will be done using the given locale.
+ * @param locale the default number formatting will be done using this
+ * locale.
+ * @param rules defines the behavior of the PluralFormat
+ * object.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ PluralFormat(const Locale& locale, const PluralRules& rules, UErrorCode& status);
+
+ /**
+ * Creates a new PluralFormat for a given pattern string.
+ * The default locale will be used to get the set of plural rules and for
+ * standard number formatting.
+ * @param pattern the pattern for this PluralFormat.
+ * errors are returned to status if the pattern is invalid.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ PluralFormat(const UnicodeString& pattern, UErrorCode& status);
+
+ /**
+ * Creates a new PluralFormat for a given pattern string and
+ * locale.
+ * The locale will be used to get the set of plural rules and for
+ * standard number formatting.
+ * @param locale the PluralFormat will be configured with
+ * rules for this locale. This locale will also be used for
+ * standard number formatting.
+ * @param pattern the pattern for this PluralFormat.
+ * errors are returned to status if the pattern is invalid.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ PluralFormat(const Locale& locale, const UnicodeString& pattern, UErrorCode& status);
+
+ /**
+ * Creates a new PluralFormat for a given set of rules, a
+ * pattern and a locale.
+ * @param rules defines the behavior of the PluralFormat
+ * object.
+ * @param pattern the pattern for this PluralFormat.
+ * errors are returned to status if the pattern is invalid.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ PluralFormat(const PluralRules& rules,
+ const UnicodeString& pattern,
+ UErrorCode& status);
+
+ /**
+ * Creates a new PluralFormat for a given set of rules, a
+ * pattern and a locale.
+ * @param locale the PluralFormat will be configured with
+ * rules for this locale. This locale will also be used for
+ * standard number formatting.
+ * @param rules defines the behavior of the PluralFormat
+ * object.
+ * @param pattern the pattern for this PluralFormat.
+ * errors are returned to status if the pattern is invalid.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ PluralFormat(const Locale& locale,
+ const PluralRules& rules,
+ const UnicodeString& pattern,
+ UErrorCode& status);
+
+ /**
+ * copy constructor.
+ * @draft ICU 4.0
+ */
+ PluralFormat(const PluralFormat& other);
+
+ /**
+ * Destructor.
+ * @draft ICU 4.0
+ */
+ virtual ~PluralFormat();
+
+ /**
+ * Sets the pattern used by this plural format.
+ * The method parses the pattern and creates a map of format strings
+ * for the plural rules.
+ * Patterns and their interpretation are specified in the class description.
+ *
+ * @param pattern the pattern for this plural format
+ * errors are returned to status if the pattern is invalid.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ void applyPattern(const UnicodeString& pattern, UErrorCode& status);
+
+ /**
+ * Formats a plural message for a given number.
+ *
+ * @param number a number for which the plural message should be formatted
+ * for. If no pattern has been applied to this
+ * PluralFormat object yet, the formatted number
+ * will be returned.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @return the string containing the formatted plural message.
+ * @draft ICU 4.0
+ */
+ UnicodeString format(int32_t number, UErrorCode& status) const;
+
+ /**
+ * Formats a plural message for a given number.
+ *
+ * @param number a number for which the plural message should be formatted
+ * for. If no pattern has been applied to this
+ * PluralFormat object yet, the formatted number
+ * will be returned.
+ * @param appendTo output parameter to receive result.
+ * result is appended to existing contents.
+ * @param pos On input: an alignment field, if desired.
+ * On output: the offsets of the alignment field.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @return the string containing the formatted plural message.
+ * @draft ICU 4.0
+ */
+ UnicodeString& format(int32_t number,
+ UnicodeString& appendTo,
+ FieldPosition& pos,
+ UErrorCode& status) const;
+
+ /**
+ * Sets the locale used by this PluraFormat object.
+ * Note: Calling this method resets this PluraFormat object,
+ * i.e., a pattern that was applied previously will be removed,
+ * and the NumberFormat is set to the default number format for
+ * the locale. The resulting format behaves the same as one
+ * constructed from {@link #PluralFormat(locale)}.
+ * @param locale the locale to use to configure the formatter.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ void setLocale(const Locale& locale, UErrorCode& status);
+
+ /**
+ * Sets the number format used by this formatter. You only need to
+ * call this if you want a different number format than the default
+ * formatter for the locale.
+ * @param format the number format to use.
+ * @param status output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @draft ICU 4.0
+ */
+ void setNumberFormat(const NumberFormat* format, UErrorCode& status);
+
+ /**
+ * Assignment operator
+ *
+ * @param other the PluralFormat object to copy from.
+ * @draft ICU 4.0
+ */
+ PluralFormat& operator=(const PluralFormat& other);
+
+ /**
+ * Return true if another object is semantically equal to this one.
+ *
+ * @param other the PluralFormat object to be compared with.
+ * @return true if other is semantically equal to this.
+ * @draft ICU 4.0
+ */
+ virtual UBool operator==(const Format& other) const;
+
+ /**
+ * Return true if another object is semantically unequal to this one.
+ *
+ * @param other the PluralFormat object to be compared with.
+ * @return true if other is semantically unequal to this.
+ * @draft ICU 4.0
+ */
+ virtual UBool operator!=(const Format& other) const;
+
+ /**
+ * Clones this Format object polymorphically. The caller owns the
+ * result and should delete it when done.
+ * @draft ICU 4.0
+ */
+ virtual Format* clone(void) const;
+
+ /**
+ * Redeclared Format method.
+ *
+ * @param obj The object to be formatted into a string.
+ * @param appendTo output parameter to receive result.
+ * Result is appended to existing contents.
+ * @param pos On input: an alignment field, if desired.
+ * On output: the offsets of the alignment field.
+ * @param status output param filled with success/failure status.
+ * @return Reference to 'appendTo' parameter.
+ * @draft ICU 4.0
+ */
+ UnicodeString& format(const Formattable& obj,
+ UnicodeString& appendTo,
+ FieldPosition& pos,
+ UErrorCode& status) const;
+
+ /**
+ * Returns the pattern from applyPattern() or constructor().
+ *
+ * @param appendTo output parameter to receive result.
+ * Result is appended to existing contents.
+ * @return the UnicodeString with inserted pattern.
+ * @draft ICU 4.0
+ */
+ UnicodeString& toPattern(UnicodeString& appendTo);
+
+ /**
+ * This method is not yet supported by PluralFormat.
+ * + * Before calling, set parse_pos.index to the offset you want to start + * parsing at in the source. After calling, parse_pos.index is the end of + * the text you parsed. If error occurs, index is unchanged. + *
+ * When parsing, leading whitespace is discarded (with a successful parse), + * while trailing whitespace is left as is. + *
+ * See Format::parseObject() for more. + * + * @param source The string to be parsed into an object. + * @param result Formattable to be set to the parse result. + * If parse fails, return contents are undefined. + * @param parse_pos The position to start parsing at. Upon return + * this param is set to the position after the + * last character successfully parsed. If the + * source is not parsed successfully, this param + * will remain unchanged. + * @draft ICU 4.0 + */ + virtual void parseObject(const UnicodeString& source, + Formattable& result, + ParsePosition& parse_pos) const; + + /** + * ICU "poor man's RTTI", returns a UClassID for this class. + * + * @draft ICU 4.0 + * + */ + static UClassID U_EXPORT2 getStaticClassID(void); + + /** + * ICU "poor man's RTTI", returns a UClassID for the actual class. + * + * @draft ICU 4.0 + */ + virtual UClassID getDynamicClassID() const; + +private: +typedef enum fmtToken { + none, + tLetter, + tNumber, + tSpace, + tNumberSign, + tLeftBrace, + tRightBrace, + }fmtToken; + + Locale locale; + PluralRules* pluralRules; + UnicodeString pattern; + Hashtable *fParsedValuesHash; + NumberFormat* numberFormat; + NumberFormat* replacedNumberFormat; + + PluralFormat(); // default constructor not implemented + void init(const PluralRules* rules, const Locale& curlocale, UErrorCode& status); + UBool inRange(UChar ch, fmtToken& type); + UBool checkSufficientDefinition(); + void parsingFailure(); + UnicodeString insertFormattedNumber(int32_t number, + UnicodeString& message, + UnicodeString& appendTo, + FieldPosition& pos) const; + void copyHashtable(Hashtable *other, UErrorCode& status); +}; + +U_NAMESPACE_END + +#endif /* #if !UCONFIG_NO_FORMATTING */ + +#endif // _PLURFMT +//eof diff --git a/icu4c/source/i18n/unicode/plurrule.h b/icu4c/source/i18n/unicode/plurrule.h new file mode 100644 index 00000000000..8b635aea526 --- /dev/null +++ b/icu4c/source/i18n/unicode/plurrule.h @@ -0,0 +1,262 @@ +/* +******************************************************************************* +* Copyright (C) 2007, International Business Machines Corporation and +* others. All Rights Reserved. +******************************************************************************* +* +* +* File PLURRULE.H +* +* Modification History:* +* Date Name Description +* +******************************************************************************** +*/ + +#ifndef PLURRULE +#define PLURRULE + +/** + * \file + * \brief C++ API: PluralRules object + */ + +#if !UCONFIG_NO_FORMATTING + +#include "unicode/format.h" +#include "unicode/utypes.h" + +U_NAMESPACE_BEGIN + +class Hashtable; +class RuleChain; +class RuleParser; + + /** + * Defines rules for mapping positive long values onto a small set of + * keywords. Rules are constructed from a text description, consisting + * of a series of keywords and conditions. The {@link #select} method + * examines each condition in order and returns the keyword for the + * first condition that matches the number. If none match, + * default rule(other) is returned. + * + * Examples:
+ * "one: n is 1; few: n in 2..4"+ * This defines two rules, for 'one' and 'few'. The condition for + * 'one' is "n is 1" which means that the number must be equal to + * 1 for this condition to pass. The condition for 'few' is + * "n in 2..4" which means that the number must be between 2 and + * 4 inclusive for this condition to pass. All other numbers + * are assigned the keyword "other" by the default rule. + *
+ * "zero: n is 0; one: n is 1; zero: n mod 100 in 1..19"+ * This illustrates that the same keyword can be defined multiple times. + * Each rule is examined in order, and the first keyword whose condition + * passes is the one returned. Also notes that a modulus is applied + * to n in the last rule. Thus its condition holds for 119, 219, 319... + *
+ * "one: n is 1; few: n mod 10 in 2..4 and n mod 100 not in 12..14"+ * This illustrates conjunction and negation. The condition for 'few' + * has two parts, both of which must be met: "n mod 10 in 2..4" and + * "n mod 100 not in 12..14". The first part applies a modulus to n + * before the test as in the previous example. The second part applies + * a different modulus and also uses negation, thus it matches all + * numbers _not_ in 12, 13, 14, 112, 113, 114, 212, 213, 214... + *
+ *
+ * Keywords
+ * could be defined by users or from ICU locale data. There are 6
+ * predefined values in ICU - 'zero', 'one', 'two', 'few', 'many' and
+ * 'other'. Callers need to check the value of keyword returned by
+ * {@link #select} method.
+ *
+ *
+ * Examples:
+ * UnicodeString keyword = pl->select(number);
+ * if (keyword== UnicodeString("one") {
+ * ...
+ * }
+ * else if ( ... )
+ *
+ */
+class U_I18N_API PluralRules : public UObject {
+public:
+
+ /**
+ * Constructor.
+ * @param status Output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ *
+ * @draft ICU 4.0
+ */
+ PluralRules(UErrorCode& status);
+
+ /**
+ * Copy constructor.
+ * @draft ICU 4.0
+ */
+ PluralRules(const PluralRules& other);
+
+ /**
+ * Destructor.
+ * @draft ICU 4.0
+ */
+ virtual ~PluralRules();
+
+ /**
+ * Clone
+ * @draft ICU 4.0
+ */
+ PluralRules* clone() const;
+
+ /**
+ * Assignment operator.
+ * @draft ICU 4.0
+ */
+ PluralRules& operator=(const PluralRules&);
+
+ /**
+ * Creates a PluralRules from a description if it is parsable, otherwise
+ * returns null.
+ *
+ * @param description rule description
+ * @param status Output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @return new PluralRules pointer. NULL if there is an error.
+ * @draft ICU 4.0
+ */
+ static PluralRules* U_EXPORT2 createRules(const UnicodeString& description,
+ UErrorCode& status);
+
+ /**
+ * The default rules that accept any number.
+ *
+ * @param status Output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @return new PluralRules pointer. NULL if there is an error.
+ * @draft ICU 4.0
+ */
+ static PluralRules* U_EXPORT2 createDefaultRules(UErrorCode& status);
+
+ /**
+ * Provides access to the predefined PluralRules for a given
+ * locale.
+ *
+ * @param locale The locale for which a PluralRules object is
+ * returned.
+ * @param status Output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @return The predefined PluralRules object pointer for
+ * this locale. If there's no predefined rules for this locale,
+ * the rules for the closest parent in the locale hierarchy
+ * that has one will be returned. The final fallback always
+ * returns the default 'other' rules.
+ * @draft ICU 4.0
+ */
+ static PluralRules* U_EXPORT2 forLocale(const Locale& locale, UErrorCode& status);
+
+ /**
+ * Given a number, returns the keyword of the first rule that applies to
+ * the number. This function can be used with isKeyword* functions to
+ * determine the keyword for default plural rules.
+ *
+ * @param number The number for which the rule has to be determined.
+ * @return The keyword of the selected rule.
+ * @draft ICU 4.0
+ */
+ UnicodeString select(int32_t number) const;
+
+ /**
+ * Returns a list of all rule keywords used in this PluralRules
+ * object. The rule 'other' is always present by default.
+ *
+ * @param status Output param set to success/failure code on exit, which
+ * must not indicate a failure before the function call.
+ * @return StringEnumeration with the keywords.
+ * The caller must delete the object.
+ * @draft ICU 4.0
+ */
+ StringEnumeration* getKeywords(UErrorCode& status) const;
+
+ /**
+ * Returns TRUE if the given keyword is defined in this
+ * PluralRules object.
+ *
+ * @param keyword the input keyword.
+ * @return TRUE if the input keyword is defined.
+ * Otherwise, return FALSE.
+ * @draft ICU 4.0
+ */
+ UBool isKeyword(const UnicodeString& keyword) const;
+
+
+ /**
+ * Returns keyword for default plural form.
+ *
+ * @return keyword for default plural form.
+ * @internal 4.0
+ * @draft ICU 4.0
+ */
+ UnicodeString getKeywordOther() const;
+
+ /**
+ * Compares the equality of two PluralRules objects.
+ *
+ * @param other The other PluralRules object to be compared with.
+ * @return True if the given PluralRules is the same as this
+ * PluralRules; false otherwise.
+ * @draft ICU 4.0
+ */
+ virtual UBool operator==(const PluralRules& other) const;
+
+ /**
+ * Compares the inequality of two PluralRules objects.
+ *
+ * @param other The PluralRules object to be compared with.
+ * @return True if the given PluralRules is not the same as this
+ * PluralRules; false otherwise.
+ * @draft ICU 4.0
+ */
+ UBool operator!=(const PluralRules& other) const {return !operator==(other);}
+
+
+ /**
+ * ICU "poor man's RTTI", returns a UClassID for this class.
+ *
+ * @draft ICU 4.0
+ *
+ */
+ static UClassID U_EXPORT2 getStaticClassID(void);
+
+ /**
+ * ICU "poor man's RTTI", returns a UClassID for the actual class.
+ *
+ * @draft ICU 4.0
+ */
+ virtual UClassID getDynamicClassID() const;
+
+
+private:
+ Hashtable *fLocaleStringsHash;
+ UnicodeString localeName;
+ RuleChain *rules;
+ RuleParser *parser;
+
+ PluralRules(); // default constructor not implemented
+ void getRuleData(UErrorCode& status);
+ int32_t getRepeatLimit() const;
+ UErrorCode parseDescription(UnicodeString& ruleData, RuleChain& rules);
+ void getNextLocale(const UnicodeString& localeData, int32_t* curIndex, UnicodeString& localeName);
+ void addRules(RuleChain& rules, UErrorCode& err);
+ void addRules(const UnicodeString& localeName, RuleChain& rules, UBool addToHash, UErrorCode& err);
+ void initHashtable(UErrorCode& err);
+ int32_t getNumberValue(const UnicodeString& token) const;
+
+};
+
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
+
+#endif // _PLURRULE
+//eof
diff --git a/icu4c/source/test/intltest/Makefile.in b/icu4c/source/test/intltest/Makefile.in
index 27a0424b3bd..0ba2939bce4 100644
--- a/icu4c/source/test/intltest/Makefile.in
+++ b/icu4c/source/test/intltest/Makefile.in
@@ -45,7 +45,7 @@ fldset.o dadrfmt.o dadrcal.o dadrcoll.o dcfmapts.o decoll.o dtfmapts.o dtfmrgts.
dtptngts.o encoll.o escoll.o ficoll.o frcoll.o g7coll.o intltest.o \
itercoll.o itformat.o itmajor.o itutil.o jacoll.o lcukocol.o \
loctest.o miscdtfm.o mnkytst.o msfmrgts.o nmfmapts.o nmfmtrt.o \
-numfmtst.o numrgts.o pptest.o regcoll.o restest.o restsnew.o \
+numfmtst.o numrgts.o plurults.o plurfmts.o pptest.o regcoll.o restest.o restsnew.o \
sdtfmtts.o svccoll.o tchcfmt.o \
tfsmalls.o tmsgfmt.o trcoll.o tscoll.o tsdate.o tsdcfmsy.o tsdtfmsy.o \
tsmthred.o tsnmfmt.o tsputil.o tstnrapi.o tstnorm.o tzbdtest.o \
diff --git a/icu4c/source/test/intltest/intltest.vcproj b/icu4c/source/test/intltest/intltest.vcproj
index 7284d2e15e1..ec52ac8e1c3 100644
--- a/icu4c/source/test/intltest/intltest.vcproj
+++ b/icu4c/source/test/intltest/intltest.vcproj
@@ -717,6 +717,18 @@
RelativePath=".\pptest.h"
>