Lines Matching refs:pattern
93 * UnicodeString pattern;
112 * pattern = ((DecimalFormat*)form)->toPattern(pattern);
113 * cout << locales[i].getDisplayName(displayName) << ": " << pattern;
145 * <p>A DecimalFormat consists of a <em>pattern</em> and a set of
146 * <em>symbols</em>. The pattern may be set directly using
148 * manipulate aspects of the pattern, such as the minimum number of integer
151 * pattern and symbols are read from ICU's locale data.
153 * <p><strong>Special Pattern Characters</strong>
155 * <p>Many characters in a pattern are taken literally; they are matched during
159 * replacement character is the same as the pattern character; in the U.S. locale,
166 * <p>To insert a special character in a pattern as a literal, that is, without
252 * If present in a pattern, the monetary decimal separator
269 * <p>A DecimalFormat pattern contains a postive and negative
298 * is 3, and the secondary is 2, then this corresponds to the pattern
300 * pattern contains multiple grouping separators, the interval between the last
308 * <p><strong>Pattern BNF</strong>
311 * pattern := subpattern (';' subpattern)?
336 * sigDigits elements, between any two pattern characters of that
344 * locales they differ. For example, the pattern
381 * specified either using a pattern or using the API. The following
431 * notation through the API or through the pattern. In a pattern, the exponent
440 * from the pattern. This allows patterns such as "0.###E0 m/s". To prefix
492 * <td align=left>Pattern
531 * example, the pattern <code>"@@@"</code> indicates exactly 3
532 * significant digits. The pattern <code>"@##"</code> indicates from
535 * significant digits have been shown. For example, the pattern
539 * <li>If a pattern uses significant digits, it may not contain a
540 * decimal separator, nor the <code>'0'</code> pattern character.
551 * <li>In order to enable significant digits formatting, use a pattern
552 * containing the <code>'@'</code> pattern character. Alternatively,
556 * pattern that does not contain the <code>'@'</code> pattern
562 * patterns are equivalent to a normal exponential pattern with a minimum and
566 * pattern <code>"@@###E0"</code> is equivalent to <code>"0.0###E0"</code>.
579 * through the API or through the pattern syntax. In a pattern the pad escape
590 * the pattern <code>"* #0 o''clock"</code>, the format width is 10.
595 * used, because the pattern width is significant with padding. In the pattern
607 * <li>When specified in a pattern, the 32-bit code point immediately
609 * including a special pattern character. That is, the pad escape
611 * the pad escape, then the pattern is illegal.
620 * or in a pattern. To specify a rounding increment in a pattern, include the
621 * increment in the pattern itself. "#,#50" specifies a rounding increment of
635 * <li>In a pattern, digits '1' through '9' specify rounding, but otherwise
688 * Create a DecimalFormat using the default pattern and symbols
697 * pattern is invalid this will be set to a failure code.
703 * Create a DecimalFormat from the given pattern and the symbols
711 * @param pattern A non-localized pattern string.
713 * pattern is invalid this will be set to a failure code.
716 DecimalFormat(const UnicodeString& pattern,
720 * Create a DecimalFormat from the given pattern and symbols.
730 * @param pattern a non-localized pattern string
734 * pattern is invalid this will be set to a failure code.
737 DecimalFormat( const UnicodeString& pattern,
743 * Create a DecimalFormat from the given pattern, symbols, and style.
745 * @param pattern a non-localized pattern string
750 * pattern is invalid this will be set to a failure code.
753 DecimalFormat( const UnicodeString& pattern,
759 pattern and symbols.
769 * @param pattern a non-localized pattern string
774 * pattern is invalid this will be set to a failure code.
777 DecimalFormat( const UnicodeString& pattern,
782 * Create a DecimalFormat from the given pattern and symbols.
792 * @param pattern a non-localized pattern string
795 * pattern is invalid this will be set to a failure code.
798 DecimalFormat( const UnicodeString& pattern,
1055 * that is, if it does not contain the currency pattern symbol
1480 * the number 123456789 formats as "1,23,45,6789", and the pattern
1525 * Synthesizes a pattern string that represents the current state
1528 * @param result Output param which will receive the pattern.
1537 * Synthesizes a localized pattern string that represents the current
1540 * @param result Output param which will receive the localized pattern.
1549 * Apply the given pattern to this Format object. A pattern is a
1557 * For negative numbers, use a second pattern, separated by a semicolon
1567 * these are presumed to be set in the positive pattern.
1569 * @param pattern The pattern to be applied.
1573 * exit. If the pattern is invalid, this will be
1577 virtual void applyPattern(const UnicodeString& pattern,
1581 * Sets the pattern.
1582 * @param pattern The pattern to be applied.
1584 * exit. If the pattern is invalid, this will be
1588 virtual void applyPattern(const UnicodeString& pattern,
1592 * Apply the given pattern to this Format object. The pattern
1593 * is assumed to be in a localized notation. A pattern is a
1601 pattern, separated by a semicolon
1611 * these are presumed to be set in the positive pattern.
1613 * @param pattern The localized pattern to be applied.
1617 * exit. If the pattern is invalid, this will be
1621 virtual void applyLocalizedPattern(const UnicodeString& pattern,
1626 * Apply the given pattern to this Format object.
1628 * @param pattern The localized pattern to be applied.
1630 * exit. If the pattern is invalid, this will be
1634 virtual void applyLocalizedPattern(const UnicodeString& pattern,
1746 * currency format through the application of a new pattern.
1810 const UnicodeString* pattern = 0,
1815 * Does the real work of generating a pattern.
1817 * @param result Output param which will receive the pattern.
1819 * @param localized TRUE return localized pattern.
1825 * Does the real work of applying a pattern.
1826 * @param pattern The pattern to be applied.
1827 * @param localized If true, the pattern is localized; else false.
1831 * exit. If the pattern is invalid, this will be
1834 void applyPattern(const UnicodeString& pattern,
1843 const UnicodeString& pattern,
1849 * only apply pattern without expand affixes
1851 void applyPatternWithoutExpandAffix(const UnicodeString& pattern,
1910 // It parses against the current currency pattern
1913 // and parses against the current pattern using simple affix comparison.
1975 void expandAffix(const UnicodeString& pattern,
1981 void expandAffix(const UnicodeString& pattern,
2001 // If currency changes, the affix pattern for currency is not changed,
2008 // pattern and the unique affix patterns of the plural currency patterns.
2013 // It sets up both fAffixesForCurrency for currency pattern if the current
2014 // pattern contains 3 currency signs,
2016 void setupCurrencyAffixes(const UnicodeString& pattern,
2093 // pattern used in this formatter
2096 // DecimalFormat(pattern, decimalFormatSymbol, style)
2113 * every currency format pattern,
2114 * including the pattern of default currecny style
2119 // negative prefix pattern
2121 // negative suffix pattern
2123 // positive prefix pattern
2125 // positive suffix pattern
2142 /* affix for currency formatting when the currency sign in the pattern
2143 * equals to 3, such as the pattern contains 3 currency sign or
2169 // Affix pattern set for currency.
2171 // each element of the set saves the negative prefix pattern,
2172 // negative suffix pattern, positive prefix pattern,
2173 // and positive suffix pattern of a pattern.
2176 // The set contains the default currency pattern from the locale,
2179 // For example, if 2 currency plural patterns are the same, only one pattern
2187 // negative suffix, positive prefix, and positive suffix of a pattern.
2191 Hashtable* fAffixesForCurrency; // for current pattern
2192 Hashtable* fPluralAffixesForCurrency; // for plural pattern
