MessageFormat Class Reference

MessageFormat produces concatenated messages in a language-neutral way. More...

#include <msgfmt.h>

Inheritance diagram for MessageFormat:
Format UObject UMemory

Public Types

enum  EFormatNumber { kMaxFormat = 10 }
 

Enum type for kMaxFormat.

More...

Public Member Functions

 MessageFormat (const UnicodeString &pattern, UErrorCode &status)
 Constructs a new MessageFormat using the given pattern and the default locale.
 MessageFormat (const UnicodeString &pattern, const Locale &newLocale, UErrorCode &status)
 Constructs a new MessageFormat using the given pattern and locale.
 MessageFormat (const UnicodeString &pattern, const Locale &newLocale, UParseError &parseError, UErrorCode &status)
 Constructs a new MessageFormat using the given pattern and locale.
 MessageFormat (const MessageFormat &)
 Constructs a new MessageFormat from an existing one.
const MessageFormatoperator= (const MessageFormat &)
 Assignment operator.
virtual ~MessageFormat ()
 Destructor.
virtual Formatclone (void) const
 Clones this Format object polymorphically.
virtual UBool operator== (const Format &other) const
 Returns true if the given Format objects are semantically equal.
virtual void setLocale (const Locale &theLocale)
 Sets the locale.
virtual const LocalegetLocale (void) const
 Gets the locale.
virtual void applyPattern (const UnicodeString &pattern, UErrorCode &status)
 Applies the given pattern string to this message format.
virtual void applyPattern (const UnicodeString &pattern, UParseError &parseError, UErrorCode &status)
 Applies the given pattern string to this message format.
virtual UnicodeStringtoPattern (UnicodeString &appendTo) const
 Returns a pattern that can be used to recreate this object.
virtual void adoptFormats (Format **formatsToAdopt, int32_t count)
 Sets subformats.
virtual void setFormats (const Format **newFormats, int32_t cnt)
 Sets subformats.
virtual void adoptFormat (int32_t formatNumber, Format *formatToAdopt)
 Sets one subformat.
virtual void setFormat (int32_t formatNumber, const Format &format)
 Sets one subformat.
virtual StringEnumerationgetFormatNames (UErrorCode &status)
 Gets format names.
virtual FormatgetFormat (const UnicodeString &formatName, UErrorCode &status)
 Gets subformat pointer for given format name.
virtual void setFormat (const UnicodeString &formatName, const Format &format, UErrorCode &status)
 Sets one subformat for given format name.
virtual void adoptFormat (const UnicodeString &formatName, Format *formatToAdopt, UErrorCode &status)
 Sets one subformat for given format name.
virtual const Format ** getFormats (int32_t &count) const
 Gets an array of subformats of this object.
UnicodeStringformat (const Formattable *source, int32_t count, UnicodeString &appendTo, FieldPosition &ignore, UErrorCode &status) const
 Formats the given array of arguments into a user-readable string.
virtual UnicodeStringformat (const Formattable &obj, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const
 Formats the given array of arguments into a user-readable string.
UnicodeStringformat (const Formattable &obj, UnicodeString &appendTo, UErrorCode &status) const
 Formats the given array of arguments into a user-readable string.
UnicodeStringformat (const UnicodeString *argumentNames, const Formattable *arguments, int32_t count, UnicodeString &appendTo, UErrorCode &status) const
 Formats the given array of arguments into a user-defined argument name array.
virtual Formattableparse (const UnicodeString &source, ParsePosition &pos, int32_t &count) const
 Parses the given string into an array of output arguments.
virtual Formattableparse (const UnicodeString &source, int32_t &count, UErrorCode &status) const
 Parses the given string into an array of output arguments.
virtual void parseObject (const UnicodeString &source, Formattable &result, ParsePosition &pos) const
 Parses the given string into an array of output arguments stored within a single Formattable of type kArray.
UBool usesNamedArguments () const
 Returns true if this MessageFormat uses named arguments, and false otherwise.
int32_t getArgTypeCount () const
 This API is for ICU internal use only.
virtual UClassID getDynamicClassID (void) const
 Returns a unique class ID POLYMORPHICALLY.

Static Public Member Functions

static UnicodeStringformat (const UnicodeString &pattern, const Formattable *arguments, int32_t count, UnicodeString &appendTo, UErrorCode &status)
 Formats the given array of arguments into a user-readable string using the given pattern.
static UnicodeString autoQuoteApostrophe (const UnicodeString &pattern, UErrorCode &status)
 Convert an 'apostrophe-friendly' pattern into a standard pattern.
static UClassID getStaticClassID (void)
 Return the class ID for this class.

Friends

class MessageFormatAdapter

Detailed Description

MessageFormat produces concatenated messages in a language-neutral way.

Use this whenever concatenating strings that are displayed to end users.

A MessageFormat contains an array of subformats arranged within a template string. Together, the subformats and template string determine how the MessageFormat will operate during formatting and parsing.

Typically, both the subformats and the template string are specified at once in a pattern. By using different patterns for different locales, messages may be localized.

When formatting, MessageFormat takes an array of arguments and produces a user-readable string. Each argument is a Formattable object; they may be passed in in an array, or as a single Formattable object which itself contains an array. Each argument is matched up with its corresponding subformat, which then formats it into a string. The resulting strings are then assembled within the string template of the MessageFormat to produce the final output string.

Note: In ICU 4.0 MessageFormat supports named arguments. If a named argument is used, all arguments must be named. Names start with a character in UCHAR_ID_START and continue with characters in UCHARID_CONTINUE, in particular they do not start with a digit. If named arguments are used, usesNamedArguments() will return true.

The other new methods supporting named arguments are getFormatNames(UErrorCode& status), getFormat(const UnicodeString& formatName, UErrorCode& status) setFormat(const UnicodeString& formatName, const Format& format, UErrorCode& status), adoptFormat(const UnicodeString& formatName, Format* formatToAdopt, UErrorCode& status), 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.

If this format uses named arguments, certain methods that take or return arrays do not perform any action, since it is not possible to identify positions in an array using a name. Of these methods, UErrorCode is set to U_ILLEGAL_ARGUMENT_ERROR by format, and to U_ARGUMENT_TYPE_MISMATCH by parse. These methods are adoptFormats(Format** formatsToAdopt, int32_t count), setFormats(const Format** newFormats,int32_t count), adoptFormat(int32_t n, Format *newFormat), setFormat(int32_t n, Format& newFormat), format(const Formattable* source, int32_t count, UnicodeString& appendTo, FieldPosition& ignore, UErrorCode& success), format(const UnicodeString& pattern,const Formattable* arguments,int32_t cnt,UnicodeString& appendTo,UErrorCode& success), format(const Formattable& source, UnicodeString& appendTo, FieldPosition& ignore, UErrorCode& success), format(const Formattable* arguments, int32_t cnt, UnicodeString& appendTo, FieldPosition& status, int32_t recursionProtection,UErrorCode& success), parse(const UnicodeString& source, ParsePosition& pos, int32_t& count), 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 objects. Plain text of the template string is matched directly against input text. At each position in the template string where a subformat is located, the subformat is called to parse the corresponding segment of input text to produce an output argument. In this way, an array of arguments is created which together constitute the parse result.

Parsing may fail or produce unexpected results in a number of circumstances.

Here are some examples of usage:

Example 1:

 
     UErrorCode success = U_ZERO_ERROR;
     GregorianCalendar cal(success);
     Formattable arguments[] = {
         7L,
         Formattable( (Date) cal.getTime(success), Formattable::kIsDate),
         "a disturbance in the Force"
     };

     UnicodeString result;
     MessageFormat::format(
          "At {1,time} on {1,date}, there was {2} on planet {0,number}.",
          arguments, 3, result, success );

     cout << "result: " << result << endl;
     //<output>: At 4:34:20 PM on 23-Mar-98, there was a disturbance
     //             in the Force on planet 7.

Typically, the message format will come from resources, and the arguments will be dynamically set at runtime.

Example 2:

  
     success = U_ZERO_ERROR;
     Formattable testArgs[] = {3L, "MyDisk"};

     MessageFormat form(
         "The disk \"{1}\" contains {0} file(s).", success );

     UnicodeString string;
     FieldPosition fpos = 0;
     cout << "format: " << form.format(testArgs, 2, string, fpos, success ) << endl;

     // output, with different testArgs:
     // output: The disk "MyDisk" contains 0 file(s).
     // output: The disk "MyDisk" contains 1 file(s).
     // output: The disk "MyDisk" contains 1,273 file(s).

The pattern is of the following form. Legend:

 
       {optional item}
       (group that may be repeated)*

Do not confuse optional items with items inside quoted braces, such as this: "{". Quoted braces are literals.

  
       messageFormatPattern := string ( "{" messageFormatElement "}" string )*

       messageFormatElement := argumentIndex | argumentName { "," elementFormat }

       elementFormat := "time" { "," datetimeStyle }
                      | "date" { "," datetimeStyle }
                      | "number" { "," numberStyle }
                      | "choice" "," choiceStyle
                      | "spellout" { "," spelloutStyle }
                      | "ordinal" { "," spelloutStyle }
                      | "duration" { "," spelloutStyle }
                      | "plural" "," pluralStyle
                      | "select" "," selectStyle

       datetimeStyle := "short"
                      | "medium"
                      | "long"
                      | "full"
                      | dateFormatPattern

       numberStyle :=   "currency"
                      | "percent"
                      | "integer"
                      | numberFormatPattern

       choiceStyle :=   choiceFormatPattern
 
       pluralStyle :=   pluralFormatPattern

       selectStyle :=   selectFormatPattern

       spelloutStyle := ruleSetName

If there is no elementFormat, then the argument must be a string, which is substituted. If there is no dateTimeStyle or numberStyle, then the default format is used (e.g. NumberFormat::createInstance(), DateFormat::createTimeInstance(DateFormat::kDefault, ...) or DateFormat::createDateInstance(DateFormat::kDefault, ...). For a RuleBasedNumberFormat, if there is no ruleSetName, the default rule set is used. For a ChoiceFormat or PluralFormat or SelectFormat, the pattern must always be specified, since there is no default.

In strings, single quotes can be used to quote syntax characters. A literal single quote is represented by '', both within and outside of single-quoted segments. Inside a messageFormatElement, quotes are not removed. For example, {1,number,$'#',##} will produce a number format with the pound-sign quoted, with a result such as: "$#31,45".

If a pattern is used, then unquoted braces in the pattern, if any, must match: that is, "ab {0} de" and "ab '}' de" are ok, but "ab {0'}' de" and "ab } de" are not.

Warning:
The rules for using quotes within message format patterns unfortunately have shown to be somewhat confusing. In particular, it isn't always obvious to localizers whether single quotes need to be doubled or not. Make sure to inform localizers about the rules, and tell them (for example, by using comments in resource bundle source files) which strings will be processed by MessageFormat. Note that localizers may need to use single quotes in translated strings where the original version doesn't have them.
Note also that the simplest way to avoid the problem is to use the real apostrophe (single quote) character U+2019 (') for human-readable text, and to use the ASCII apostrophe (U+0027 ' ) only in program syntax, like quoting in MessageFormat. See the annotations for U+0027 Apostrophe in The Unicode Standard.

The argumentIndex is a non-negative integer, which corresponds to the index of the arguments presented in an array to be formatted. The first argument has argumentIndex 0.

It is acceptable to have unused arguments in the array. With missing arguments, or arguments that are not of the right class for the specified format, a failing UErrorCode result is set.

For more sophisticated patterns, you can use a ChoiceFormat to get output:

 
     UErrorCode success = U_ZERO_ERROR;
     MessageFormat* form("The disk \"{1}\" contains {0}.", success);
     double filelimits[] = {0,1,2};
     UnicodeString filepart[] = {"no files","one file","{0,number} files"};
     ChoiceFormat* fileform = new ChoiceFormat(filelimits, filepart, 3);
     form.setFormat(1, *fileform); // NOT zero, see below

     Formattable testArgs[] = {1273L, "MyDisk"};

     UnicodeString string;
     FieldPosition fpos = 0;
     cout << form.format(testArgs, 2, string, fpos, success) << endl;

     // output, with different testArgs
     // output: The disk "MyDisk" contains no files.
     // output: The disk "MyDisk" contains one file.
     // output: The disk "MyDisk" contains 1,273 files.

You can either do this programmatically, as in the above example, or by using a pattern (see ChoiceFormat for more information) as in:

 
    form.applyPattern(
      "There {0,choice,0#are no files|1#is one file|1<are {0,number,integer} files}.");

Note: As we see above, the string produced by a ChoiceFormat in MessageFormat is treated specially; occurences of '{' are used to indicated subformats, and cause recursion. If you create both a MessageFormat and ChoiceFormat programmatically (instead of using the string patterns), then be careful not to produce a format that recurses on itself, which will cause an infinite loop.

Note: Subformats are numbered by their order in the pattern. This is not the same as the argumentIndex.

 
    For example: with "abc{2}def{3}ghi{0}...",

    format0 affects the first variable {2}
    format1 affects the second variable {3}
    format2 affects the second variable {0}

User subclasses are not supported. While clients may write subclasses, such code will not necessarily work and will not be guaranteed to work stably from release to release.

Definition at line 317 of file msgfmt.h.


Member Enumeration Documentation

Enum type for kMaxFormat.

Obsolete:
ICU 3.0. The 10-argument limit was removed as of ICU 2.6, rendering this enum type obsolete.
Enumerator:
kMaxFormat 

The maximum number of arguments.

Obsolete:
ICU 3.0. The 10-argument limit was removed as of ICU 2.6, rendering this constant obsolete.

Definition at line 324 of file msgfmt.h.


Constructor & Destructor Documentation

MessageFormat::MessageFormat ( const UnicodeString pattern,
UErrorCode status 
)

Constructs a new MessageFormat using the given pattern and the default locale.

Parameters:
pattern Pattern used to construct object.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Stable:
ICU 2.0
MessageFormat::MessageFormat ( const UnicodeString pattern,
const Locale newLocale,
UErrorCode status 
)

Constructs a new MessageFormat using the given pattern and locale.

Parameters:
pattern Pattern used to construct object.
newLocale The locale to use for formatting dates and numbers.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Stable:
ICU 2.0
MessageFormat::MessageFormat ( const UnicodeString pattern,
const Locale newLocale,
UParseError parseError,
UErrorCode status 
)

Constructs a new MessageFormat using the given pattern and locale.

Parameters:
pattern Pattern used to construct object.
newLocale The locale to use for formatting dates and numbers.
parseError Struct to recieve information on position of error within the pattern.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Stable:
ICU 2.0
MessageFormat::MessageFormat ( const MessageFormat  ) 

Constructs a new MessageFormat from an existing one.

Stable:
ICU 2.0
virtual MessageFormat::~MessageFormat (  )  [virtual]

Destructor.

Stable:
ICU 2.0

Member Function Documentation

virtual void MessageFormat::adoptFormat ( const UnicodeString formatName,
Format formatToAdopt,
UErrorCode status 
) [virtual]

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.

Parameters:
formatName Name of the subformat.
formatToAdopt Format to be adopted.
status output param set to success/failure code.
Stable:
ICU 4.0
virtual void MessageFormat::adoptFormat ( int32_t  formatNumber,
Format formatToAdopt 
) [virtual]

Sets one subformat.

See the class description about format numbering. The caller should not delete the Format object after this call. If the number is over the number of formats already set, the item will be deleted and ignored.

If this format uses named arguments, the new format is discarded and this format remains unchanged.

Stable:
ICU 2.0
Parameters:
formatNumber index of the subformat.
formatToAdopt the format to be adopted.
virtual void MessageFormat::adoptFormats ( Format **  formatsToAdopt,
int32_t  count 
) [virtual]

Sets subformats.

See the class description about format numbering. The caller should not delete the Format objects after this call. The array formatsToAdopt is not itself adopted. Its ownership is retained by the caller. If the call fails because memory cannot be allocated, then the formats will be deleted by this method, and this object will remain unchanged.

If this format uses named arguments, the new formats are discarded and this format remains unchanged.

Stable:
ICU 2.0
Parameters:
formatsToAdopt the format to be adopted.
count the size of the array.
virtual void MessageFormat::applyPattern ( const UnicodeString pattern,
UParseError parseError,
UErrorCode status 
) [virtual]

Applies the given pattern string to this message format.

Parameters:
pattern The pattern to be applied.
parseError Struct to recieve information on position of error within pattern.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Stable:
ICU 2.0
virtual void MessageFormat::applyPattern ( const UnicodeString pattern,
UErrorCode status 
) [virtual]

Applies the given pattern string to this message format.

Parameters:
pattern The pattern to be applied.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Stable:
ICU 2.0
static UnicodeString MessageFormat::autoQuoteApostrophe ( const UnicodeString pattern,
UErrorCode status 
) [static]

Convert an 'apostrophe-friendly' pattern into a standard pattern.

Standard patterns treat all apostrophes as quotes, which is problematic in some languages, e.g. French, where apostrophe is commonly used. This utility assumes that only an unpaired apostrophe immediately before a brace is a true quote. Other unpaired apostrophes are paired, and the resulting standard pattern string is returned.

Note it is not guaranteed that the returned pattern is indeed a valid pattern. The only effect is to convert between patterns having different quoting semantics.

Parameters:
pattern the 'apostrophe-friendly' patttern to convert
status Input/output error code. If the pattern cannot be parsed, the failure code is set.
Returns:
the standard equivalent of the original pattern
Stable:
ICU 3.4
virtual Format* MessageFormat::clone ( void   )  const [virtual]

Clones this Format object polymorphically.

The caller owns the result and should delete it when done.

Stable:
ICU 2.0

Implements Format.

UnicodeString& MessageFormat::format ( const UnicodeString argumentNames,
const Formattable arguments,
int32_t  count,
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"...).

Parameters:
argumentNames argument name array
arguments An array of objects to be formatted.
count The number of elements of 'argumentNames' and arguments. The number of argumentNames and arguments must be the same.
appendTo Output parameter to receive result. Result is appended to existing contents.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Returns:
Reference to 'appendTo' parameter.
Stable:
ICU 4.0
UnicodeString & MessageFormat::format ( const Formattable obj,
UnicodeString appendTo,
UErrorCode status 
) const [inline]

Formats the given array of arguments into a user-readable string.

The array must be stored within a single Formattable object of type kArray. If the Formattable object type is not of type kArray, then returns a failing UErrorCode.

Parameters:
obj The object to format
appendTo Output parameter to receive result. Result is appended to existing contents.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Returns:
Reference to 'appendTo' parameter.
Stable:
ICU 2.0

Reimplemented from Format.

Definition at line 973 of file msgfmt.h.

References format().

virtual UnicodeString& MessageFormat::format ( const Formattable obj,
UnicodeString appendTo,
FieldPosition pos,
UErrorCode status 
) const [virtual]

Formats the given array of arguments into a user-readable string.

The array must be stored within a single Formattable object of type kArray. If the Formattable object type is not of type kArray, then returns a failing UErrorCode.

If this format uses named arguments, appendTo is unchanged and status is set to U_ILLEGAL_ARGUMENT_ERROR.

Parameters:
obj A Formattable of type kArray containing arguments to be formatted.
appendTo Output parameter to receive result. Result is appended to existing contents.
pos On input: an alignment field, if desired. On output: the offsets of the alignment field.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Returns:
Reference to 'appendTo' parameter.
Stable:
ICU 2.0

Implements Format.

static UnicodeString& MessageFormat::format ( const UnicodeString pattern,
const Formattable arguments,
int32_t  count,
UnicodeString appendTo,
UErrorCode status 
) [static]

Formats the given array of arguments into a user-readable string using the given pattern.

If this format uses named arguments, appendTo is unchanged and status is set to U_ILLEGAL_ARGUMENT_ERROR.

Parameters:
pattern The pattern.
arguments An array of objects to be formatted.
count The number of elements of 'source'.
appendTo Output parameter to receive result. Result is appended to existing contents.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Returns:
Reference to 'appendTo' parameter.
Stable:
ICU 2.0
UnicodeString& MessageFormat::format ( const Formattable source,
int32_t  count,
UnicodeString appendTo,
FieldPosition ignore,
UErrorCode status 
) const

Formats the given array of arguments into a user-readable string.

Does not take ownership of the Formattable* array or its contents.

If this format uses named arguments, appendTo is unchanged and status is set to U_ILLEGAL_ARGUMENT_ERROR.

Parameters:
source An array of objects to be formatted.
count The number of elements of 'source'.
appendTo Output parameter to receive result. Result is appended to existing contents.
ignore Not used; inherited from base class API.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Returns:
Reference to 'appendTo' parameter.
Stable:
ICU 2.0

Referenced by format().

int32_t MessageFormat::getArgTypeCount (  )  const

This API is for ICU internal use only.

Please do not use it.

Returns argument types count in the parsed pattern. Used to distinguish pattern "{0} d" and "d".

Returns:
The number of formattable types in the pattern
Internal:
Do not use. This API is for internal use only.
virtual UClassID MessageFormat::getDynamicClassID ( void   )  const [virtual]

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.

Returns:
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.
Stable:
ICU 2.0

Implements Format.

virtual Format* MessageFormat::getFormat ( const UnicodeString formatName,
UErrorCode status 
) [virtual]

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.

Parameters:
formatName the name or number specifying a format
status output param set to success/failure code.
Stable:
ICU 4.0
virtual StringEnumeration* MessageFormat::getFormatNames ( UErrorCode status  )  [virtual]

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.

Parameters:
status output param set to success/failure code.
Stable:
ICU 4.0
virtual const Format** MessageFormat::getFormats ( int32_t &  count  )  const [virtual]

Gets an array of subformats of this object.

The returned array should not be deleted by the caller, nor should the pointers within the array. The array and its contents remain valid only until the next call to this format. See the class description about format numbering.

Parameters:
count output parameter to receive the size of the array
Returns:
an array of count Format* objects, or NULL if out of memory. Any or all of the array elements may be NULL.
Stable:
ICU 2.0
virtual const Locale& MessageFormat::getLocale ( void   )  const [virtual]

Gets the locale.

This locale is used for fetching default number or date format information.

Returns:
the locale of the object.
Stable:
ICU 2.0
static UClassID MessageFormat::getStaticClassID ( void   )  [static]

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()) ...
 
Returns:
The class ID for all objects of this class.
Stable:
ICU 2.0
const MessageFormat& MessageFormat::operator= ( const MessageFormat  ) 

Assignment operator.

Stable:
ICU 2.0

Reimplemented from Format.

virtual UBool MessageFormat::operator== ( const Format other  )  const [virtual]

Returns true if the given Format objects are semantically equal.

Objects of different subclasses are considered unequal.

Parameters:
other the object to be compared with.
Returns:
true if the given Format objects are semantically equal.
Stable:
ICU 2.0
virtual Formattable* MessageFormat::parse ( const UnicodeString source,
int32_t &  count,
UErrorCode status 
) const [virtual]

Parses the given string into an array of output arguments.

If this format uses named arguments, status is set to U_ARGUMENT_TYPE_MISMATCH.

Parameters:
source String to be parsed.
count Output param to receive size of returned array.
status Input/output error code. If the pattern cannot be parsed, set to failure code.
Returns:
an array of parsed arguments. The caller owns both the array and its contents. Returns NULL if status is not U_ZERO_ERROR.
Stable:
ICU 2.0
virtual Formattable* MessageFormat::parse ( const UnicodeString source,
ParsePosition pos,
int32_t &  count 
) const [virtual]

Parses the given string into an array of output arguments.

Parameters:
source String to be parsed.
pos On input, starting position for parse. On output, final position after parse. Unchanged if parse fails.
count Output parameter to receive the number of arguments parsed.
Returns:
an array of parsed arguments. The caller owns both the array and its contents.
Stable:
ICU 2.0
virtual void MessageFormat::parseObject ( const UnicodeString source,
Formattable result,
ParsePosition pos 
) const [virtual]

Parses the given string into an array of output arguments stored within a single Formattable of type kArray.

Parameters:
source The string to be parsed into an object.
result Formattable to be set to the parse result. If parse fails, return contents are undefined.
pos On input, starting position for parse. On output, final position after parse. Unchanged if parse fails.
Stable:
ICU 2.0

Implements Format.

virtual void MessageFormat::setFormat ( const UnicodeString formatName,
const Format format,
UErrorCode status 
) [virtual]

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.

Parameters:
formatName Name of the subformat.
format the format to be set.
status output param set to success/failure code.
Stable:
ICU 4.0
virtual void MessageFormat::setFormat ( int32_t  formatNumber,
const Format format 
) [virtual]

Sets one subformat.

See the class description about format numbering. If the number is over the number of formats already set, the item will be ignored.

Parameters:
formatNumber index of the subformat.
format the format to be set.
Stable:
ICU 2.0
virtual void MessageFormat::setFormats ( const Format **  newFormats,
int32_t  cnt 
) [virtual]

Sets subformats.

See the class description about format numbering. Each item in the array is cloned into the internal array. If the call fails because memory cannot be allocated, then this object will remain unchanged.

If this format uses named arguments, the new formats are discarded and this format remains unchanged.

Stable:
ICU 2.0
Parameters:
newFormats the new format to be set.
cnt the size of the array.
virtual void MessageFormat::setLocale ( const Locale theLocale  )  [virtual]

Sets the locale.

This locale is used for fetching default number or date format information.

Parameters:
theLocale the new locale value to be set.
Stable:
ICU 2.0
virtual UnicodeString& MessageFormat::toPattern ( UnicodeString appendTo  )  const [virtual]

Returns a pattern that can be used to recreate this object.

Parameters:
appendTo Output parameter to receive the pattern. Result is appended to existing contents.
Returns:
Reference to 'appendTo' parameter.
Stable:
ICU 2.0
UBool MessageFormat::usesNamedArguments (  )  const

Returns true if this MessageFormat uses named arguments, and false otherwise.

See class description.

Returns:
true if named arguments are used.
Stable:
ICU 4.0

The documentation for this class was generated from the following file:
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on Sat Jan 23 15:17:43 2010 for ICU 4.3.4 by  doxygen 1.6.1