Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1MessageFormat.html below:

ICU 77.1: icu::MessageFormat Class Reference

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 numeric value is formatted with a default (for the locale) NumberFormat, and a date/time value is formatted with a default (for the locale) DateFormat.

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

MessageFormat uses patterns of the following form:

message = messageText (argument messageText)*
argument = noneArg | simpleArg | complexArg
complexArg = choiceArg | pluralArg | selectArg | selectordinalArg

noneArg = '{' argNameOrNumber '}'
simpleArg = '{' argNameOrNumber ',' argType [',' argStyle] '}'
choiceArg = '{' argNameOrNumber ',' "choice" ',' choiceStyle '}'
pluralArg = '{' argNameOrNumber ',' "plural" ',' pluralStyle '}'
selectArg = '{' argNameOrNumber ',' "select" ',' selectStyle '}'
selectordinalArg = '{' argNameOrNumber ',' "selectordinal" ',' pluralStyle '}'

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 | "::" argSkeletonText

• messageText can contain quoted literal strings including syntax characters. A quoted literal string begins with an ASCII apostrophe and a syntax character (usually a {curly brace}) and continues until the next single apostrophe. A double ASCII apostrophe inside or outside of a quoted string represents one literal apostrophe.
• Quotable syntax characters are the {curly braces} in all messageText parts, plus the '#' sign in a messageText immediately inside a pluralStyle, and the '|' symbol in a messageText immediately inside a choiceStyle.
• See also UMessagePatternApostropheMode
• In argStyleText, every single ASCII apostrophe begins and ends quoted literal text, and unquoted {curly braces} must occur in matched pairs.

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 choice argument type is deprecated. Use plural arguments for proper plural selection, and select arguments for simple selection among a fixed set of choices.

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.

Arguments are formatted according to their type, using the default ICU formatters for those types, unless otherwise specified.

There are also several ways to control the formatting.

We recommend you use default styles, predefined style values, skeletons, or preformatted values, but not pattern strings or custom format objects.

For more details, see the ICU User Guide.

Here are some examples of usage: Example 1:

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

UnicodeString result;

     "At {1,time,::jmm} on {1,date,::dMMMM}, there was {2} on planet {0,number}.",
     arguments, 3, result, success );

cout << "result: " << result << endl;


UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, UErrorCode &status) const
Formats an object to produce a string.
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
@ U_ZERO_ERROR
No error, no warning.

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

Example 2:

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


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

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





MessageFormat(const UnicodeString &pattern, UErrorCode &status)
Constructs a new MessageFormat using the given pattern and the default locale.

 

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

     "{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.

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 345 of file msgfmt.h.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4