Lines Matching refs:pattern
98 * UnicodeString pattern;
117 * pattern = ((DecimalFormat*)form)->toPattern(pattern);
118 * cout << locales[i].getDisplayName(displayName) << ": " << pattern;
150 * <p>A DecimalFormat consists of a <em>pattern</em> and a set of
151 * <em>symbols</em>. The pattern may be set directly using
153 * manipulate aspects of the pattern, such as the minimum number of integer
156 * pattern and symbols are read from ICU's locale data.
158 * <p><strong>Special Pattern Characters</strong>
160 * <p>Many characters in a pattern are taken literally; they are matched during
164 * replacement character is the same as the pattern character; in the U.S. locale,
171 * <p>To insert a special character in a pattern as a literal, that is, without
257 * If present in a pattern, the monetary decimal separator
274 * <p>A DecimalFormat pattern contains a postive and negative
303 * is 3, and the secondary is 2, then this corresponds to the pattern
305 * pattern contains multiple grouping separators, the interval between the last
313 * <p><strong>Pattern BNF</strong>
316 * pattern := subpattern (';' subpattern)?
341 * sigDigits elements, between any two pattern characters of that
349 * locales they differ. For example, the pattern
387 * specified either using a pattern or using the API. The following
437 * notation through the API or through the pattern. In a pattern, the exponent
446 * from the pattern. This allows patterns such as "0.###E0 m/s". To prefix
498 * <td align=left>Pattern
537 * example, the pattern <code>"@@@"</code> indicates exactly 3
538 * significant digits. The pattern <code>"@##"</code> indicates from
541 * significant digits have been shown. For example, the pattern
545 * <li>If a pattern uses significant digits, it may not contain a
546 * decimal separator, nor the <code>'0'</code> pattern character.
557 * <li>In order to enable significant digits formatting, use a pattern
558 * containing the <code>'@'</code> pattern character. Alternatively,
562 * pattern that does not contain the <code>'@'</code> pattern
568 * patterns are equivalent to a normal exponential pattern with a minimum and
572 * pattern <code>"@@###E0"</code> is equivalent to <code>"0.0###E0"</code>.
585 * through the API or through the pattern syntax. In a pattern the pad escape
596 * the pattern <code>"* #0 o''clock"</code>, the format width is 10.
601 * used, because the pattern width is significant with padding. In the pattern
613 * <li>When specified in a pattern, the 32-bit code point immediately
615 * including a special pattern character. That is, the pad escape
617 * the pad escape, then the pattern is illegal.
626 * or in a pattern. To specify a rounding increment in a pattern, include the
627 * increment in the pattern itself. "#,#50" specifies a rounding increment of
640 * through the API; it can not be set with a pattern.
645 * <li>In a pattern, digits '1' through '9' specify rounding, but otherwise
696 * Create a DecimalFormat using the default pattern and symbols
705 * pattern is invalid this will be set to a failure code.
711 * Create a DecimalFormat from the given pattern and the symbols
719 * @param pattern A non-localized pattern string.
721 * pattern is invalid this will be set to a failure code.
724 DecimalFormat(const UnicodeString& pattern,
728 * Create a DecimalFormat from the given pattern and symbols.
738 * @param pattern a non-localized pattern string
742 * pattern is invalid this will be set to a failure code.
745 DecimalFormat( const UnicodeString& pattern,
752 * Create a DecimalFormat from the given pattern, symbols, and style.
754 * @param pattern a non-localized pattern string
759 * pattern is invalid this will be set to a failure code.
762 DecimalFormat( const UnicodeString& pattern,
804 * Create a DecimalFormat from the given pattern and symbols.
814 * @param pattern a non-localized pattern string
819 * pattern is invalid this will be set to a failure code.
822 DecimalFormat( const UnicodeString& pattern,
827 * Create a DecimalFormat from the given pattern and symbols.
837 * @param pattern a non-localized pattern string
840 * pattern is invalid this will be set to a failure code.
843 DecimalFormat( const UnicodeString& pattern,
1218 * that is, if it does not contain the currency pattern symbol
1641 * the number 123456789 formats as "1,23,45,6789", and the pattern
1686 * Synthesizes a pattern string that represents the current state
1689 * @param result Output param which will receive the pattern.
1698 * Synthesizes a localized pattern string that represents the current
1701 * @param result Output param which will receive the localized pattern.
1710 * Apply the given pattern to this Format object. A pattern is a
1718 * For negative numbers, use a second pattern, separated by a semicolon
1728 * these are presumed to be set in the positive pattern.
1730 * @param pattern The pattern to be applied.
1734 * exit. If the pattern is invalid, this will be
1738 virtual void applyPattern(const UnicodeString& pattern,
1742 * Sets the pattern.
1743 * @param pattern The pattern to be applied.
1745 * exit. If the pattern is invalid, this will be
1749 virtual void applyPattern(const UnicodeString& pattern,
1753 * Apply the given pattern to this Format object. The pattern
1754 * is assumed to be in a localized notation. A pattern is a
1762 * For negative numbers, use a second pattern, separated by a semicolon
1772 * these are presumed to be set in the positive pattern.
1774 * @param pattern The localized pattern to be applied.
1778 * exit. If the pattern is invalid, this will be
1782 virtual void applyLocalizedPattern(const UnicodeString& pattern,
1787 * Apply the given pattern to this Format object.
1789 * @param pattern The localized pattern to be applied.
1791 * exit. If the pattern is invalid, this will be
1795 virtual void applyLocalizedPattern(const UnicodeString& pattern,
1907 * currency format through the application of a new pattern.
1975 const UnicodeString* pattern = 0,
1980 * Does the real work of generating a pattern.
1982 * @param result Output param which will receive the pattern.
1984 * @param localized TRUE return localized pattern.
1990 * Does the real work of applying a pattern.
1991 * @param pattern The pattern to be applied.
1992 * @param localized If true, the pattern is localized; else false.
1996 * exit. If the pattern is invalid, this will be
1999 void applyPattern(const UnicodeString& pattern,
2008 const UnicodeString& pattern,
2014 * only apply pattern without expand affixes
2016 void applyPatternWithoutExpandAffix(const UnicodeString& pattern,
2067 // It parses against the current currency pattern
2070 // and parses against the current pattern using simple affix comparison.
2145 void expandAffix(const UnicodeString& pattern,
2163 // If currency changes, the affix pattern for currency is not changed,
2170 // pattern and the unique affix patterns of the plural currency patterns.
2175 // It sets up both fAffixesForCurrency for currency pattern if the current
2176 // pattern contains 3 currency signs,
2178 void setupCurrencyAffixes(const UnicodeString& pattern,
2265 // pattern used in this formatter
2268 // DecimalFormat(pattern, decimalFormatSymbol, style)
2285 * every currency format pattern,
2286 * including the pattern of default currecny style
2292 // negative prefix pattern
2294 // negative suffix pattern
2296 // positive prefix pattern
2298 // positive suffix pattern
2316 /* affix for currency formatting when the currency sign in the pattern
2317 * equals to 3, such as the pattern contains 3 currency sign or
2345 // Affix pattern set for currency.
2347 // each element of the set saves the negative prefix pattern,
2348 // negative suffix pattern, positive prefix pattern,
2349 // and positive suffix pattern of a pattern.
2352 // The set contains the default currency pattern from the locale,
2355 // For example, if 2 currency plural patterns are the same, only one pattern
2363 // negative suffix, positive prefix, and positive suffix of a pattern.
2367 Hashtable* fAffixesForCurrency; // for current pattern
2368 Hashtable* fPluralAffixesForCurrency; // for plural pattern
