Lines Matching refs:pattern
82 * UnicodeString pattern;
101 * pattern = ((DecimalFormat*)form)->toPattern(pattern);
102 * cout << locales[i].getDisplayName(displayName) << ": " << pattern;
134 * <p>A DecimalFormat consists of a <em>pattern</em> and a set of
135 * <em>symbols</em>. The pattern may be set directly using
137 * manipulate aspects of the pattern, such as the minimum number of integer
140 * pattern and symbols are read from ICU's locale data.
142 * <p><strong>Special Pattern Characters</strong>
144 * <p>Many characters in a pattern are taken literally; they are matched during
148 * replacement character is the same as the pattern character; in the U.S. locale,
155 * <p>To insert a special character in a pattern as a literal, that is, without
241 * If present in a pattern, the monetary decimal separator
258 * <p>A DecimalFormat pattern contains a postive and negative
287 * is 3, and the secondary is 2, then this corresponds to the pattern
289 * pattern contains multiple grouping separators, the interval between the last
297 * <p><strong>Pattern BNF</strong>
300 * pattern := subpattern (';' subpattern)?
325 * sigDigits elements, between any two pattern characters of that
333 * locales they differ. For example, the pattern
370 * specified either using a pattern or using the API. The following
420 * notation through the API or through the pattern. In a pattern, the exponent
429 * from the pattern. This allows patterns such as "0.###E0 m/s". To prefix
481 * <td align=left>Pattern
520 * example, the pattern <code>"@@@"</code> indicates exactly 3
521 * significant digits. The pattern <code>"@##"</code> indicates from
524 * significant digits have been shown. For example, the pattern
528 * <li>If a pattern uses significant digits, it may not contain a
529 * decimal separator, nor the <code>'0'</code> pattern character.
540 * <li>In order to enable significant digits formatting, use a pattern
541 * containing the <code>'@'</code> pattern character. Alternatively,
545 * pattern that does not contain the <code>'@'</code> pattern
551 * patterns are equivalent to a normal exponential pattern with a minimum and
555 * pattern <code>"@@###E0"</code> is equivalent to <code>"0.0###E0"</code>.
568 * through the API or through the pattern syntax. In a pattern the pad escape
579 * the pattern <code>"* #0 o''clock"</code>, the format width is 10.
584 * used, because the pattern width is significant with padding. In the pattern
596 * <li>When specified in a pattern, the 32-bit code point immediately
598 * including a special pattern character. That is, the pad escape
600 * the pad escape, then the pattern is illegal.
609 * or in a pattern. To specify a rounding increment in a pattern, include the
610 * increment in the pattern itself. "#,#50" specifies a rounding increment of
623 * through the API; it can not be set with a pattern.
628 * <li>In a pattern, digits '1' through '9' specify rounding, but otherwise
675 * Create a DecimalFormat using the default pattern and symbols
684 * pattern is invalid this will be set to a failure code.
690 * Create a DecimalFormat from the given pattern and the symbols
698 * @param pattern A non-localized pattern string.
700 * pattern is invalid this will be set to a failure code.
703 DecimalFormat(const UnicodeString& pattern,
707 * Create a DecimalFormat from the given pattern and symbols.
717 * @param pattern a non-localized pattern string
721 * pattern is invalid this will be set to a failure code.
724 DecimalFormat( const UnicodeString& pattern,
730 * Create a DecimalFormat from the given pattern, symbols, and style.
732 * @param pattern a non-localized pattern string
737 * pattern is invalid this will be set to a failure code.
740 DecimalFormat( const UnicodeString& pattern,
746 * Create a DecimalFormat from the given pattern and symbols.
756 * @param pattern a non-localized pattern string
761 * pattern is invalid this will be set to a failure code.
764 DecimalFormat( const UnicodeString& pattern,
769 * Create a DecimalFormat from the given pattern and symbols.
779 * @param pattern a non-localized pattern string
782 * pattern is invalid this will be set to a failure code.
785 DecimalFormat( const UnicodeString& pattern,
1109 * that is, if it does not contain the currency pattern symbol
1533 * the number 123456789 formats as "1,23,45,6789", and the pattern
1578 * Synthesizes a pattern string that represents the current state
1581 * @param result Output param which will receive the pattern.
1590 * Synthesizes a localized pattern
1593 * @param result Output param which will receive the localized pattern.
1602 * Apply the given pattern to this Format object. A pattern is a
1610 * For negative numbers, use a second pattern, separated by a semicolon
1620 * these are presumed to be set in the positive pattern.
1622 * @param pattern The pattern to be applied.
1626 * exit. If the pattern is invalid, this will be
1630 virtual void applyPattern(const UnicodeString& pattern,
1634 * Sets the pattern.
1635 * @param pattern The pattern to be applied.
1637 * exit. If the pattern is invalid, this will be
1641 virtual void applyPattern(const UnicodeString& pattern,
1645 * Apply the given pattern to this Format object. The pattern
1646 * is assumed to be in a localized notation. A pattern is a
1654 * For negative numbers, use a second pattern, separated by a semicolon
1664 * these are presumed to be set in the positive pattern.
1666 * @param pattern The localized pattern to be applied.
1670 * exit. If the pattern is invalid, this will be
1674 virtual void applyLocalizedPattern(const UnicodeString& pattern,
1679 * Apply the given pattern to this Format object.
1681 * @param pattern The localized pattern to be applied.
1683 * exit. If the pattern is invalid, this will be
1687 virtual void applyLocalizedPattern(const UnicodeString& pattern,
1799 * currency format through the application of a new pattern.
1867 const UnicodeString* pattern = 0,
1872 * Does the real work of generating a pattern.
1874 * @param result Output param which will receive the pattern.
1876 * @param localized TRUE return localized pattern.
1882 * Does the real work of applying a pattern.
1883 * @param pattern The pattern to be applied.
1884 * @param localized If true, the pattern is localized; else false.
1888 * exit. If the pattern is invalid, this will be
1891 void applyPattern(const UnicodeString& pattern,
1900 const UnicodeString& pattern,
1906 * only apply pattern without expand affixes
1908 void applyPatternWithoutExpandAffix(const UnicodeString& pattern,
1958 // It parses against the current currency pattern
1961 // and parses against the current pattern using simple affix comparison.
2022 void expandAffix(const UnicodeString& pattern,
2040 // If currency changes, the affix pattern for currency is not changed,
2047 // pattern and the unique affix patterns of the plural currency patterns.
2052 // It sets up both fAffixesForCurrency for currency pattern if the current
2053 // pattern contains 3 currency signs,
2055 void setupCurrencyAffixes(const UnicodeString& pattern,
2135 // pattern used in this formatter
2138 // DecimalFormat(pattern, decimalFormatSymbol, style)
2155 * every currency format pattern,
2156 * including the pattern of default currecny style
2162 // negative prefix pattern
2164 // negative suffix pattern
2166 // positive prefix pattern
2168 // positive suffix pattern
2186 /* affix for currency formatting when the currency sign in the pattern
2187 * equals to 3, such as the pattern contains 3 currency sign or
2215 // Affix pattern set for currency.
2217 // each element of the set saves the negative prefix pattern,
2218 // negative suffix pattern, positive prefix pattern,
2219 // and positive suffix pattern of a pattern.
2222 // The set contains the default currency pattern from the locale,
2225 // For example, if 2 currency plural patterns are the same, only one pattern
2233 // negative suffix, positive prefix, and positive suffix of a pattern.
2237 Hashtable* fAffixesForCurrency; // for current pattern
2238 Hashtable* fPluralAffixesForCurrency; // for plural pattern
