| /* | |
| ******************************************************************************* | |
| * Copyright (C) 2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| ******************************************************************************* | |
| * affixpatternparser.h | |
| * | |
| * created on: 2015jan06 | |
| * created by: Travis Keep | |
| */ | |
| #ifndef __AFFIX_PATTERN_PARSER_H__ | |
| #define __AFFIX_PATTERN_PARSER_H__ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| #include "unicode/unistr.h" | |
| #include "unicode/uobject.h" | |
| #include "pluralaffix.h" | |
| U_NAMESPACE_BEGIN | |
| class PluralRules; | |
| class FixedPrecision; | |
| class DecimalFormatSymbols; | |
| /** | |
| * A representation of the various forms of a particular currency according | |
| * to some locale and usage context. | |
| * | |
| * Includes the symbol, ISO code form, and long form(s) of the currency name | |
| * for each plural variation. | |
| */ | |
| class U_I18N_API CurrencyAffixInfo : public UMemory { | |
| public: | |
| /** | |
| * Symbol is \u00a4; ISO form is \u00a4\u00a4; | |
| * long form is \u00a4\u00a4\u00a4. | |
| */ | |
| CurrencyAffixInfo(); | |
| const UnicodeString &getSymbol() const { return fSymbol; } | |
| const UnicodeString &getISO() const { return fISO; } | |
| const PluralAffix &getLong() const { return fLong; } | |
| void setSymbol(const UnicodeString &symbol) { | |
| fSymbol = symbol; | |
| fIsDefault = FALSE; | |
| } | |
| void setISO(const UnicodeString &iso) { | |
| fISO = iso; | |
| fIsDefault = FALSE; | |
| } | |
| UBool | |
| equals(const CurrencyAffixInfo &other) const { | |
| return (fSymbol == other.fSymbol) | |
| && (fISO == other.fISO) | |
| && (fLong.equals(other.fLong)) | |
| && (fIsDefault == other.fIsDefault); | |
| } | |
| /** | |
| * Intializes this instance. | |
| * | |
| * @param locale the locale for the currency forms. | |
| * @param rules The plural rules for the locale. | |
| * @param currency the null terminated, 3 character ISO code of the | |
| * currency. If NULL, resets this instance as if it were just created. | |
| * In this case, the first 2 parameters may be NULL as well. | |
| * @param status any error returned here. | |
| */ | |
| void set( | |
| const char *locale, const PluralRules *rules, | |
| const UChar *currency, UErrorCode &status); | |
| /** | |
| * Returns true if this instance is the default. That is has no real | |
| * currency. For instance never initialized with set() | |
| * or reset with set(NULL, NULL, NULL, status). | |
| */ | |
| UBool isDefault() const { return fIsDefault; } | |
| /** | |
| * Adjusts the precision used for a particular currency. | |
| * @param currency the null terminated, 3 character ISO code of the | |
| * currency. | |
| * @param usage the usage of the currency | |
| * @param precision min/max fraction digits and rounding increment | |
| * adjusted. | |
| * @params status any error reported here. | |
| */ | |
| static void adjustPrecision( | |
| const UChar *currency, const UCurrencyUsage usage, | |
| FixedPrecision &precision, UErrorCode &status); | |
| private: | |
| /** | |
| * The symbol form of the currency. | |
| */ | |
| UnicodeString fSymbol; | |
| /** | |
| * The ISO form of the currency, usually three letter abbreviation. | |
| */ | |
| UnicodeString fISO; | |
| /** | |
| * The long forms of the currency keyed by plural variation. | |
| */ | |
| PluralAffix fLong; | |
| UBool fIsDefault; | |
| }; | |
| class AffixPatternIterator; | |
| /** | |
| * A locale agnostic representation of an affix pattern. | |
| */ | |
| class U_I18N_API AffixPattern : public UMemory { | |
| public: | |
| /** | |
| * The token types that can appear in an affix pattern. | |
| */ | |
| enum ETokenType { | |
| kLiteral, | |
| kPercent, | |
| kPerMill, | |
| kCurrency, | |
| kNegative, | |
| kPositive | |
| }; | |
| /** | |
| * An empty affix pattern. | |
| */ | |
| AffixPattern() | |
| : tokens(), literals(), hasCurrencyToken(FALSE), | |
| hasPercentToken(FALSE), hasPermillToken(FALSE), char32Count(0) { | |
| } | |
| /** | |
| * Adds a string literal to this affix pattern. | |
| */ | |
| void addLiteral(const UChar *, int32_t start, int32_t len); | |
| /** | |
| * Adds a token to this affix pattern. t must not be kLiteral as | |
| * the addLiteral() method adds literals. | |
| * @param t the token type to add | |
| */ | |
| void add(ETokenType t); | |
| /** | |
| * Adds a currency token with specific count to this affix pattern. | |
| * @param count the token count. Used to distinguish between | |
| * one, two, or three currency symbols. Note that adding a currency | |
| * token with count=2 (Use ISO code) is different than adding two | |
| * currency tokens each with count=1 (two currency symbols). | |
| */ | |
| void addCurrency(uint8_t count); | |
| /** | |
| * Makes this instance be an empty affix pattern. | |
| */ | |
| void remove(); | |
| /** | |
| * Provides an iterator over the tokens in this instance. | |
| * @param result this is initialized to point just before the | |
| * first token of this instance. Caller must call nextToken() | |
| * on the iterator once it is set up to have it actually point | |
| * to the first token. This first call to nextToken() will return | |
| * FALSE if the AffixPattern being iterated over is empty. | |
| * @return result | |
| */ | |
| AffixPatternIterator &iterator(AffixPatternIterator &result) const; | |
| /** | |
| * Returns TRUE if this instance has currency tokens in it. | |
| */ | |
| UBool usesCurrency() const { | |
| return hasCurrencyToken; | |
| } | |
| UBool usesPercent() const { | |
| return hasPercentToken; | |
| } | |
| UBool usesPermill() const { | |
| return hasPermillToken; | |
| } | |
| /** | |
| * Returns the number of code points a string of this instance | |
| * would have if none of the special tokens were escaped. | |
| * Used to compute the padding size. | |
| */ | |
| int32_t countChar32() const { | |
| return char32Count; | |
| } | |
| /** | |
| * Appends other to this instance mutating this instance in place. | |
| * @param other The pattern appended to the end of this one. | |
| * @return a reference to this instance for chaining. | |
| */ | |
| AffixPattern &append(const AffixPattern &other); | |
| /** | |
| * Converts this AffixPattern back into a user string. | |
| * It is the inverse of parseUserAffixString. | |
| */ | |
| UnicodeString &toUserString(UnicodeString &appendTo) const; | |
| /** | |
| * Converts this AffixPattern back into a string. | |
| * It is the inverse of parseAffixString. | |
| */ | |
| UnicodeString &toString(UnicodeString &appendTo) const; | |
| /** | |
| * Parses an affix pattern string appending it to an AffixPattern. | |
| * Parses affix pattern strings produced from using | |
| * DecimalFormatPatternParser to parse a format pattern. Affix patterns | |
| * include the positive prefix and suffix and the negative prefix | |
| * and suffix. This method expects affix patterns strings to be in the | |
| * same format that DecimalFormatPatternParser produces. Namely special | |
| * characters in the affix that correspond to a field type must be | |
| * prefixed with an apostrophe ('). These special character sequences | |
| * inluce minus (-), percent (%), permile (U+2030), plus (+), | |
| * short currency (U+00a4), medium currency (u+00a4 * 2), | |
| * long currency (u+a4 * 3), and apostrophe (') | |
| * (apostrophe does not correspond to a field type but has to be escaped | |
| * because it itself is the escape character). | |
| * Since the expansion of these special character | |
| * sequences is locale dependent, these sequences are not expanded in | |
| * an AffixPattern instance. | |
| * If these special characters are not prefixed with an apostrophe in | |
| * the affix pattern string, then they are treated verbatim just as | |
| * any other character. If an apostrophe prefixes a non special | |
| * character in the affix pattern, the apostrophe is simply ignored. | |
| * | |
| * @param affixStr the string from DecimalFormatPatternParser | |
| * @param appendTo parsed result appended here. | |
| * @param status any error parsing returned here. | |
| */ | |
| static AffixPattern &parseAffixString( | |
| const UnicodeString &affixStr, | |
| AffixPattern &appendTo, | |
| UErrorCode &status); | |
| /** | |
| * Parses an affix pattern string appending it to an AffixPattern. | |
| * Parses affix pattern strings as the user would supply them. | |
| * In this function, quoting makes special characters like normal | |
| * characters whereas in parseAffixString, quoting makes special | |
| * characters special. | |
| * | |
| * @param affixStr the string from the user | |
| * @param appendTo parsed result appended here. | |
| * @param status any error parsing returned here. | |
| */ | |
| static AffixPattern &parseUserAffixString( | |
| const UnicodeString &affixStr, | |
| AffixPattern &appendTo, | |
| UErrorCode &status); | |
| UBool equals(const AffixPattern &other) const { | |
| return (tokens == other.tokens) | |
| && (literals == other.literals) | |
| && (hasCurrencyToken == other.hasCurrencyToken) | |
| && (hasPercentToken == other.hasPercentToken) | |
| && (hasPermillToken == other.hasPermillToken) | |
| && (char32Count == other.char32Count); | |
| } | |
| private: | |
| /* | |
| * Tokens stored here. Each UChar generally stands for one token. A | |
| * Each token is of form 'etttttttllllllll' llllllll is the length of | |
| * the token and ranges from 0-255. ttttttt is the token type and ranges | |
| * from 0-127. If e is set it means this is an extendo token (to be | |
| * described later). To accomodate token lengths above 255, each normal | |
| * token (e=0) can be followed by 0 or more extendo tokens (e=1) with | |
| * the same type. Right now only kLiteral Tokens have extendo tokens. | |
| * Each extendo token provides the next 8 higher bits for the length. | |
| * If a kLiteral token is followed by 2 extendo tokens then, then the | |
| * llllllll of the next extendo token contains bits 8-15 of the length | |
| * and the last extendo token contains bits 16-23 of the length. | |
| */ | |
| UnicodeString tokens; | |
| /* | |
| * The characters of the kLiteral tokens are concatenated together here. | |
| * The first characters go with the first kLiteral token, the next | |
| * characters go with the next kLiteral token etc. | |
| */ | |
| UnicodeString literals; | |
| UBool hasCurrencyToken; | |
| UBool hasPercentToken; | |
| UBool hasPermillToken; | |
| int32_t char32Count; | |
| void add(ETokenType t, uint8_t count); | |
| }; | |
| /** | |
| * An iterator over the tokens in an AffixPattern instance. | |
| */ | |
| class U_I18N_API AffixPatternIterator : public UMemory { | |
| public: | |
| /** | |
| * Using an iterator without first calling iterator on an AffixPattern | |
| * instance to initialize the iterator results in | |
| * undefined behavior. | |
| */ | |
| AffixPatternIterator() : nextLiteralIndex(0), lastLiteralLength(0), nextTokenIndex(0), tokens(NULL), literals(NULL) { } | |
| /** | |
| * Advances this iterator to the next token. Returns FALSE when there | |
| * are no more tokens. Calling the other methods after nextToken() | |
| * returns FALSE results in undefined behavior. | |
| */ | |
| UBool nextToken(); | |
| /** | |
| * Returns the type of token. | |
| */ | |
| AffixPattern::ETokenType getTokenType() const; | |
| /** | |
| * For literal tokens, returns the literal string. Calling this for | |
| * other token types results in undefined behavior. | |
| * @param result replaced with a read-only alias to the literal string. | |
| * @return result | |
| */ | |
| UnicodeString &getLiteral(UnicodeString &result) const; | |
| /** | |
| * Returns the token length. Usually 1, but for currency tokens may | |
| * be 2 for ISO code and 3 for long form. | |
| */ | |
| int32_t getTokenLength() const; | |
| private: | |
| int32_t nextLiteralIndex; | |
| int32_t lastLiteralLength; | |
| int32_t nextTokenIndex; | |
| const UnicodeString *tokens; | |
| const UnicodeString *literals; | |
| friend class AffixPattern; | |
| AffixPatternIterator(const AffixPatternIterator &); | |
| AffixPatternIterator &operator=(const AffixPatternIterator &); | |
| }; | |
| /** | |
| * A locale aware class that converts locale independent AffixPattern | |
| * instances into locale dependent PluralAffix instances. | |
| */ | |
| class U_I18N_API AffixPatternParser : public UMemory { | |
| public: | |
| AffixPatternParser(); | |
| AffixPatternParser(const DecimalFormatSymbols &symbols); | |
| void setDecimalFormatSymbols(const DecimalFormatSymbols &symbols); | |
| /** | |
| * Parses affixPattern appending the result to appendTo. | |
| * @param affixPattern The affix pattern. | |
| * @param currencyAffixInfo contains the currency forms. | |
| * @param appendTo The result of parsing affixPattern is appended here. | |
| * @param status any error returned here. | |
| * @return appendTo. | |
| */ | |
| PluralAffix &parse( | |
| const AffixPattern &affixPattern, | |
| const CurrencyAffixInfo ¤cyAffixInfo, | |
| PluralAffix &appendTo, | |
| UErrorCode &status) const; | |
| UBool equals(const AffixPatternParser &other) const { | |
| return (fPercent == other.fPercent) | |
| && (fPermill == other.fPermill) | |
| && (fNegative == other.fNegative) | |
| && (fPositive == other.fPositive); | |
| } | |
| private: | |
| UnicodeString fPercent; | |
| UnicodeString fPermill; | |
| UnicodeString fNegative; | |
| UnicodeString fPositive; | |
| }; | |
| U_NAMESPACE_END | |
| #endif /* #if !UCONFIG_NO_FORMATTING */ | |
| #endif // __AFFIX_PATTERN_PARSER_H__ |