ICU 4.8.1.1  4.8.1.1
Data Structures | Public Types | Public Member Functions | Static Public Member Functions | Friends
MessageFormat Class Reference

#include <msgfmt.h>

Inheritance diagram for MessageFormat:
Format UObject UMemory

Data Structures

class  DummyFormat
 A DummyFormatter that we use solely to store a NULL value.
class  PluralSelectorProvider
 This provider helps defer instantiation of a PluralRules object until we actually need to select a keyword.

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 to be used for creating argument Format objects.
virtual const LocalegetLocale (void) const
 Gets the locale used for creating argument Format objects.
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 void applyPattern (const UnicodeString &pattern, UMessagePatternApostropheMode aposMode, UParseError *parseError, UErrorCode &status)
 Sets the UMessagePatternApostropheMode and the pattern used by this message format.
UMessagePatternApostropheMode getApostropheMode () const
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.
static UBool equalFormats (const void *left, const void *right)
 Compares two Format objects.

Friends

class MessageFormatAdapter

Detailed Description

MessageFormat prepares strings for display to users, with optional arguments (variables/placeholders). The arguments can occur in any order, which is necessary for translation into languages with different grammars.

A MessageFormat is constructed from a pattern string with arguments in {curly braces} which will be replaced by formatted values.

MessageFormat differs from the other Format classes in that you create a MessageFormat object with one of its constructors (not with a createInstance style factory method). Factory methods aren't necessary because MessageFormat itself doesn't implement locale-specific behavior. Any locale-specific behavior is defined by the pattern that you provide and the subformats used for inserted arguments.

Arguments can be named (using identifiers) or numbered (using small ASCII-digit integers). Some of the API methods work only with argument numbers and throw an exception if the pattern has named arguments (see usesNamedArguments()).

An argument might not specify any format type. In this case, a Number value is formatted with a default (for the locale) NumberFormat, a Date value is formatted with a default (for the locale) DateFormat, and for any other value its toString() value is used.

An argument might specify a "simple" type for which the specified Format object is created, cached and used.

An argument might have a "complex" type with nested MessageFormat sub-patterns. During formatting, one of these sub-messages is selected according to the argument value and recursively formatted.

After construction, a custom Format object can be set for a top-level argument, overriding the default formatting and parsing behavior for that argument. However, custom formatting can be achieved more simply by writing a typeless argument in the pattern string and supplying it with a preformatted string value.

When formatting, MessageFormat takes a collection of argument values and writes an output string. The argument values may be passed as an array (when the pattern contains only numbered arguments) or as an array of names and and an array of arguments (which works for both named and numbered arguments).

Each argument is matched with one of the input values by array index or argument name and formatted according to its pattern specification (or using a custom Format object if one was set). A numbered pattern argument is matched with an argument name that contains that number as an ASCII-decimal-digit string (without leading zero).

Patterns and Their Interpretation

MessageFormat uses patterns of the following form:

 message = messageText (argument messageText)*
 argument = noneArg | simpleArg | complexArg
 complexArg = choiceArg | pluralArg | selectArg
 noneArg = '{' argNameOrNumber '}'
 simpleArg = '{' argNameOrNumber ',' argType [',' argStyle] '}'
 choiceArg = '{' argNameOrNumber ',' "choice" ',' choiceStyle '}'
 pluralArg = '{' argNameOrNumber ',' "plural" ',' pluralStyle '}'
 selectArg = '{' argNameOrNumber ',' "select" ',' selectStyle '}'
 choiceStyle: see ChoiceFormat
 pluralStyle: see PluralFormat
 selectStyle: see SelectFormat
 argNameOrNumber = argName | argNumber
 argName = [^[[:Pattern_Syntax:][:Pattern_White_Space:]]]+
 argNumber = '0' | ('1'..'9' ('0'..'9')*)
 argType = "number" | "date" | "time" | "spellout" | "ordinal" | "duration"
 argStyle = "short" | "medium" | "long" | "full" | "integer" | "currency" | "percent" | argStyleText
 

Recommendation: Use the real apostrophe (single quote) character ’ (U+2019) for human-readable text, and 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 argType and argStyle values are used to create a Format instance for the format element. The following table shows how the values map to Format instances. Combinations not shown in the table are illegal. Any argStyleText must be a valid pattern string for the Format subclass used.

argType argStyle resulting Format object
(none) null
number (none) NumberFormat.createInstance(getLocale(), status)
integer NumberFormat.createInstance(getLocale(), kNumberStyle, status)
currency NumberFormat.createCurrencyInstance(getLocale(), status)
percent NumberFormat.createPercentInstance(getLocale(), status)
argStyleText new DecimalFormat(argStyleText, new DecimalFormatSymbols(getLocale(), status), status)
date (none) DateFormat.createDateInstance(kDefault, getLocale(), status)
short DateFormat.createDateInstance(kShort, getLocale(), status)
medium DateFormat.createDateInstance(kDefault, getLocale(), status)
long DateFormat.createDateInstance(kLong, getLocale(), status)
full DateFormat.createDateInstance(kFull, getLocale(), status)
argStyleText new SimpleDateFormat(argStyleText, getLocale(), status)
time (none) DateFormat.createTimeInstance(kDefault, getLocale(), status)
short DateFormat.createTimeInstance(kShort, getLocale(), status)
medium DateFormat.createTimeInstance(kDefault, getLocale(), status)
long DateFormat.createTimeInstance(kLong, getLocale(), status)
full DateFormat.createTimeInstance(kFull, getLocale(), status)
argStyleText new SimpleDateFormat(argStyleText, getLocale(), status)
spellout argStyleText (optional) new RuleBasedNumberFormat(URBNF_SPELLOUT, getLocale(), status)
    .setDefaultRuleset(argStyleText, status);
ordinal argStyleText (optional) new RuleBasedNumberFormat(URBNF_ORDINAL, getLocale(), status)
    .setDefaultRuleset(argStyleText, status);
duration argStyleText (optional) new RuleBasedNumberFormat(URBNF_DURATION, getLocale(), status)
    .setDefaultRuleset(argStyleText, status);

Usage Information

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).

For messages that include plural forms, you can use a plural argument:

 
  success = U_ZERO_ERROR;
  MessageFormat msgFmt(
       "{num_files, plural, "
       "=0{There are no files on disk \"{disk_name}\".}"
       "=1{There is one file on disk \"{disk_name}\".}"
       "other{There are # files on disk \"{disk_name}\".}}",
      Locale("en"),
      success);
  FieldPosition fpos = 0;
  Formattable testArgs[] = {0L, "MyDisk"};
  UnicodeString testArgsNames[] = {"num_files", "disk_name"};
  UnicodeString result;
  cout << msgFmt.format(testArgs, testArgsNames, 2, result, fpos, 0, success);
  testArgs[0] = 3L;
  cout << msgFmt.format(testArgs, testArgsNames, 2, result, fpos, 0, success);

output: There are no files on disk "MyDisk". There are 3 files on "MyDisk".

See PluralFormat and PluralRules for details.

Synchronization

MessageFormats are not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally.

Stable:
ICU 2.0

Definition at line 318 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 325 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:
patternPattern used to construct object.
statusInput/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:
patternPattern used to construct object.
newLocaleThe locale to use for formatting dates and numbers.
statusInput/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:
patternPattern used to construct object.
newLocaleThe locale to use for formatting dates and numbers.
parseErrorStruct to receive information on the position of an error within the pattern.
statusInput/output error code. If the pattern cannot be parsed, set to failure code.
Stable:
ICU 2.0

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 ( 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:
formatNumberindex of the subformat.
formatToAdoptthe format to be adopted.
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:
formatNameName of the subformat.
formatToAdoptFormat to be adopted.
statusoutput param set to success/failure code.
Stable:
ICU 4.0
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:
formatsToAdoptthe format to be adopted.
countthe size of the array.
virtual void MessageFormat::applyPattern ( const UnicodeString pattern,
UErrorCode status 
) [virtual]

Applies the given pattern string to this message format.

Parameters:
patternThe pattern to be applied.
statusInput/output error code. If the pattern cannot be parsed, set to failure code.
Stable:
ICU 2.0
virtual void MessageFormat::applyPattern ( const UnicodeString pattern,
UParseError parseError,
UErrorCode status 
) [virtual]

Applies the given pattern string to this message format.

Parameters:
patternThe pattern to be applied.
parseErrorStruct to receive information on the position of an error within the pattern.
statusInput/output error code. If the pattern cannot be parsed, set to failure code.
Stable:
ICU 2.0
virtual void MessageFormat::applyPattern ( const UnicodeString pattern,
UMessagePatternApostropheMode  aposMode,
UParseError parseError,
UErrorCode status 
) [virtual]

Sets the UMessagePatternApostropheMode and the pattern used by this message format.

Parses the pattern and caches Format objects for simple argument types. Patterns and their interpretation are specified in the class description.

This method is best used only once on a given object to avoid confusion about the mode, and after constructing the object with an empty pattern string to minimize overhead.

Parameters:
patternThe pattern to be applied.
aposModeThe new apostrophe mode.
parseErrorStruct to receive information on the position of an error within the pattern. Can be NULL.
statusInput/output error code. If the pattern cannot be parsed, set to failure code.
Draft:
This API may be changed in the future versions and was introduced in ICU 4.8
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:
patternthe 'apostrophe-friendly' patttern to convert
statusInput/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.

static UBool MessageFormat::equalFormats ( const void *  left,
const void *  right 
) [static]

Compares two Format objects.

This is used for constructing the hash tables.

Parameters:
leftpointer to a Format object. Must not be NULL.
rightpointer to a Format object. Must not be NULL.
Returns:
whether the two objects are the same
Internal:
Do not use. This API is for internal use only.
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:
sourceAn array of objects to be formatted.
countThe number of elements of 'source'.
appendToOutput parameter to receive result. Result is appended to existing contents.
ignoreNot used; inherited from base class API.
statusInput/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().

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:
patternThe pattern.
argumentsAn array of objects to be formatted.
countThe number of elements of 'source'.
appendToOutput parameter to receive result. Result is appended to existing contents.
statusInput/output error code. If the pattern cannot be parsed, set to failure code.
Returns:
Reference to 'appendTo' parameter.
Stable:
ICU 2.0
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:
objA Formattable of type kArray containing arguments to be formatted.
appendToOutput parameter to receive result. Result is appended to existing contents.
posOn input: an alignment field, if desired. On output: the offsets of the alignment field.
statusInput/output error code. If the pattern cannot be parsed, set to failure code.
Returns:
Reference to 'appendTo' parameter.
Stable:
ICU 2.0

Implements Format.

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:
objThe object to format
appendToOutput parameter to receive result. Result is appended to existing contents.
statusInput/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 1077 of file msgfmt.h.

References 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:
argumentNamesargument name array
argumentsAn array of objects to be formatted.
countThe number of elements of 'argumentNames' and arguments. The number of argumentNames and arguments must be the same.
appendToOutput parameter to receive result. Result is appended to existing contents.
statusInput/output error code. If the pattern cannot be parsed, set to failure code.
Returns:
Reference to 'appendTo' parameter.
Stable:
ICU 4.0
Returns:
this instance's UMessagePatternApostropheMode.
Draft:
This API may be changed in the future versions and was introduced in ICU 4.8

Definition at line 471 of file msgfmt.h.

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 UObject.

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:
formatNamethe name or number specifying a format
statusoutput param set to success/failure code.
Stable:
ICU 4.0

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 the caller's responsibility to delete the returned formatNames.

Parameters:
statusoutput 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:
countoutput 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 used for creating argument Format objects.

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
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:
otherthe object to be compared with.
Returns:
true if the given Format objects are semantically equal.
Stable:
ICU 2.0

Implements Format.

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:
sourceString to be parsed.
posOn input, starting position for parse. On output, final position after parse. Unchanged if parse fails.
countOutput 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 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:
sourceString to be parsed.
countOutput param to receive size of returned array.
statusInput/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 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:
sourceThe string to be parsed into an object.
resultFormattable to be set to the parse result. If parse fails, return contents are undefined.
posOn 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 ( 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:
formatNumberindex of the subformat.
formatthe format to be set.
Stable:
ICU 2.0
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:
formatNameName of the subformat.
formatthe format to be set.
statusoutput param set to success/failure code.
Stable:
ICU 4.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:
newFormatsthe new format to be set.
cntthe size of the array.
virtual void MessageFormat::setLocale ( const Locale theLocale) [virtual]

Sets the locale to be used for creating argument Format objects.

Parameters:
theLocalethe 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:
appendToOutput parameter to receive the pattern. Result is appended to existing contents.
Returns:
Reference to 'appendTo' parameter.
Stable:
ICU 2.0

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