| /* |
| ******************************************************************************* |
| * Copyright (C) 2007-2010, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| */ |
| #ifndef ZSTRFMT_H |
| #define ZSTRFMT_H |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include "unicode/unistr.h" |
| #include "unicode/calendar.h" |
| #include "uhash.h" |
| #include "uvector.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| /* |
| * Character node used by TextTrieMap |
| */ |
| struct CharacterNode { |
| // No constructor or destructor. |
| // We malloc and free an uninitalized array of CharacterNode objects |
| // and clear and delete them ourselves. |
| |
| void clear(); |
| void deleteValues(); |
| |
| void addValue(void *value, UErrorCode &status); |
| inline UBool hasValues() const; |
| inline int32_t countValues() const; |
| inline const void *getValue(int32_t index) const; |
| |
| void *fValues; // Union of one single value vs. UVector of values. |
| UChar fCharacter; // UTF-16 code unit. |
| uint16_t fFirstChild; // 0 if no children. |
| uint16_t fNextSibling; // 0 terminates the list. |
| UBool fHasValuesVector; |
| UBool fPadding; |
| |
| // No value: fValues == NULL and fHasValuesVector == FALSE |
| // One value: fValues == value and fHasValuesVector == FALSE |
| // >=2 values: fValues == UVector of values and fHasValuesVector == TRUE |
| }; |
| |
| inline UBool CharacterNode::hasValues() const { |
| return (UBool)(fValues != NULL); |
| } |
| |
| inline int32_t CharacterNode::countValues() const { |
| return |
| fValues == NULL ? 0 : |
| !fHasValuesVector ? 1 : |
| ((const UVector *)fValues)->size(); |
| } |
| |
| inline const void *CharacterNode::getValue(int32_t index) const { |
| if (!fHasValuesVector) { |
| return fValues; // Assume index == 0. |
| } else { |
| return ((const UVector *)fValues)->elementAt(index); |
| } |
| } |
| |
| /* |
| * Search result handler callback interface used by TextTrieMap search. |
| */ |
| class TextTrieMapSearchResultHandler : public UMemory { |
| public: |
| virtual UBool handleMatch(int32_t matchLength, |
| const CharacterNode *node, UErrorCode& status) = 0; |
| virtual ~TextTrieMapSearchResultHandler(); //added to avoid warning |
| }; |
| |
| |
| /* |
| * ZSFStringPool Pool of (UChar *) strings. Provides for sharing of repeated |
| * strings within ZoneStringFormats. |
| */ |
| class ZSFStringPoolChunk; |
| class ZSFStringPool: public UMemory { |
| public: |
| ZSFStringPool(UErrorCode &status); |
| ~ZSFStringPool(); |
| |
| /* Get the pooled string that is equal to the supplied string s. |
| * Copy the string into the pool if it is not already present. |
| * |
| * Life time of the returned string is that of the pool. |
| */ |
| const UChar *get(const UChar *s, UErrorCode &status); |
| |
| /* Get the pooled string that is equal to the supplied string s. |
| * Copy the string into the pool if it is not already present. |
| */ |
| const UChar *get(const UnicodeString &s, UErrorCode &status); |
| |
| /* Adopt a string into the pool, without copying it. |
| * Used for strings from resource bundles, which will persist without copying. |
| */ |
| const UChar *adopt(const UChar *s, UErrorCode &status); |
| |
| /* Freeze the string pool. Discards the hash table that is used |
| * for looking up a string. All pointers to pooled strings remain valid. |
| */ |
| void freeze(); |
| |
| private: |
| ZSFStringPoolChunk *fChunks; |
| UHashtable *fHash; |
| }; |
| |
| |
| /** |
| * TextTrieMap is a trie implementation for supporting |
| * fast prefix match for the string key. |
| */ |
| class TextTrieMap : public UMemory { |
| public: |
| TextTrieMap(UBool ignoreCase); |
| virtual ~TextTrieMap(); |
| |
| void put(const UnicodeString &key, void *value, ZSFStringPool &sp, UErrorCode &status); |
| void search(const UnicodeString &text, int32_t start, |
| TextTrieMapSearchResultHandler *handler, UErrorCode& status) const; |
| int32_t isEmpty() const; |
| |
| private: |
| UBool fIgnoreCase; |
| CharacterNode *fNodes; |
| int32_t fNodesCapacity; |
| int32_t fNodesCount; |
| |
| UVector *fLazyContents; |
| UBool fIsEmpty; |
| |
| UBool growNodes(); |
| CharacterNode* addChildNode(CharacterNode *parent, UChar c, UErrorCode &status); |
| CharacterNode* getChildNode(CharacterNode *parent, UChar c) const; |
| |
| void putImpl(const UnicodeString &key, void *value, UErrorCode &status); |
| void buildTrie(UErrorCode &status); |
| void search(CharacterNode *node, const UnicodeString &text, int32_t start, |
| int32_t index, TextTrieMapSearchResultHandler *handler, UErrorCode &status) const; |
| }; |
| |
| |
| // Name types, these bit flag are used for zone string lookup |
| enum TimeZoneTranslationType { |
| LOCATION = 0x0001, |
| GENERIC_LONG = 0x0002, |
| GENERIC_SHORT = 0x0004, |
| STANDARD_LONG = 0x0008, |
| STANDARD_SHORT = 0x0010, |
| DAYLIGHT_LONG = 0x0020, |
| DAYLIGHT_SHORT = 0x0040 |
| }; |
| |
| // Name type index, these constants are used for index in the zone strings array. |
| enum TimeZoneTranslationTypeIndex { |
| ZSIDX_LOCATION = 0, |
| ZSIDX_LONG_STANDARD, |
| ZSIDX_SHORT_STANDARD, |
| ZSIDX_LONG_DAYLIGHT, |
| ZSIDX_SHORT_DAYLIGHT, |
| ZSIDX_LONG_GENERIC, |
| ZSIDX_SHORT_GENERIC, |
| |
| ZSIDX_COUNT |
| }; |
| |
| class MessageFormat; |
| |
| |
| /* |
| * ZoneStringInfo is a class holding a localized zone string |
| * information. |
| */ |
| class ZoneStringInfo : public UMemory { |
| public: |
| virtual ~ZoneStringInfo(); |
| |
| inline UnicodeString& getID(UnicodeString &result) const; |
| inline UnicodeString& getString(UnicodeString &result) const; |
| inline UBool isStandard(void) const; |
| inline UBool isDaylight(void) const; |
| inline UBool isGeneric(void) const; |
| |
| private: |
| friend class ZoneStringFormat; |
| friend class ZoneStringSearchResultHandler; |
| |
| ZoneStringInfo(const UnicodeString &id, const UnicodeString &str, |
| TimeZoneTranslationType type, ZSFStringPool &sp, UErrorCode &status); |
| |
| const UChar *fId; |
| const UChar *fStr; |
| TimeZoneTranslationType fType; |
| }; |
| |
| inline UnicodeString& ZoneStringInfo::getID(UnicodeString &result) const { |
| return result.setTo(fId, -1); |
| } |
| |
| inline UnicodeString& ZoneStringInfo::getString(UnicodeString &result) const { |
| return result.setTo(fStr, -1); |
| } |
| |
| inline UBool ZoneStringInfo::isStandard(void) const { |
| return (fType == STANDARD_LONG || fType == STANDARD_SHORT); |
| } |
| |
| inline UBool ZoneStringInfo::isDaylight(void) const { |
| return (fType == DAYLIGHT_LONG || fType == DAYLIGHT_SHORT); |
| } |
| |
| inline UBool ZoneStringInfo::isGeneric(void) const { |
| return (fType == LOCATION || fType == GENERIC_LONG || fType == GENERIC_SHORT); |
| } |
| |
| class SafeZoneStringFormatPtr; |
| |
| class ZoneStringFormat : public UMemory { |
| public: |
| ZoneStringFormat(const UnicodeString* const* strings, int32_t rowCount, int32_t columnCount, UErrorCode &status); |
| ZoneStringFormat(const Locale& locale, UErrorCode &status); |
| virtual ~ZoneStringFormat(); |
| |
| /* Gets zone string format from cache if available, create it if not cached. */ |
| static SafeZoneStringFormatPtr* getZoneStringFormat(const Locale& locale, UErrorCode &status); |
| |
| /* |
| * Create a snapshot of old zone strings array for the given date |
| */ |
| UnicodeString** createZoneStringsArray(UDate date, int32_t &rowCount, int32_t &colCount, UErrorCode &status) const; |
| |
| /* TODO: There is no implementation for this function. Delete declaration? */ |
| const UnicodeString** getZoneStrings(int32_t &rowCount, int32_t &columnCount) const; |
| |
| UnicodeString& getSpecificLongString(const Calendar &cal, |
| UnicodeString &result, UErrorCode &status) const; |
| |
| UnicodeString& getSpecificShortString(const Calendar &cal, |
| UBool commonlyUsedOnly, UnicodeString &result, UErrorCode &status) const; |
| |
| UnicodeString& getGenericLongString(const Calendar &cal, |
| UnicodeString &result, UErrorCode &status) const; |
| |
| UnicodeString& getGenericShortString(const Calendar &cal, |
| UBool commonlyUsedOnly, UnicodeString &result, UErrorCode &status) const; |
| |
| UnicodeString& getGenericLocationString(const Calendar &cal, |
| UnicodeString &result, UErrorCode &status) const; |
| |
| const ZoneStringInfo* findSpecificLong(const UnicodeString &text, int32_t start, |
| int32_t &matchLength, UErrorCode &status) const; |
| const ZoneStringInfo* findSpecificShort(const UnicodeString &text, int32_t start, |
| int32_t &matchLength, UErrorCode &status) const; |
| const ZoneStringInfo* findGenericLong(const UnicodeString &text, int32_t start, |
| int32_t &matchLength, UErrorCode &status) const; |
| const ZoneStringInfo* findGenericShort(const UnicodeString &text, int32_t start, |
| int32_t &matchLength, UErrorCode &status) const; |
| const ZoneStringInfo* findGenericLocation(const UnicodeString &text, int32_t start, |
| int32_t &matchLength, UErrorCode &status) const; |
| |
| // Following APIs are not used by SimpleDateFormat, but public for testing purpose |
| inline UnicodeString& getLongStandard(const UnicodeString &tzid, UDate date, |
| UnicodeString &result) const; |
| inline UnicodeString& getLongDaylight(const UnicodeString &tzid, UDate date, |
| UnicodeString &result) const; |
| inline UnicodeString& getLongGenericNonLocation(const UnicodeString &tzid, UDate date, |
| UnicodeString &result) const; |
| inline UnicodeString& getLongGenericPartialLocation(const UnicodeString &tzid, UDate date, |
| UnicodeString &result) const; |
| inline UnicodeString& getShortStandard(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly, |
| UnicodeString &result) const; |
| inline UnicodeString& getShortDaylight(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly, |
| UnicodeString &result) const; |
| inline UnicodeString& getShortGenericNonLocation(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly, |
| UnicodeString &result) const; |
| inline UnicodeString& getShortGenericPartialLocation(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly, |
| UnicodeString &result) const; |
| inline UnicodeString& getGenericLocation(const UnicodeString &tzid, UnicodeString &result) const; |
| |
| private: |
| Locale fLocale; |
| UHashtable *fTzidToStrings; |
| UHashtable *fMzidToStrings; |
| |
| TextTrieMap fZoneStringsTrie; |
| ZSFStringPool fStringPool; |
| |
| UResourceBundle *fZoneStringsArray; |
| UResourceBundle *fMetazoneItem; |
| UResourceBundle *fZoneItem; |
| |
| UBool fIsFullyLoaded; |
| |
| void loadZone(const UnicodeString &utzid, UErrorCode &status); |
| void addSingleZone(UnicodeString &utzid, UErrorCode &status); |
| void loadFull(UErrorCode &status); |
| |
| |
| /* |
| * Private method to get a zone string except generic partial location types. |
| */ |
| UnicodeString& getString(const UnicodeString &tzid, TimeZoneTranslationTypeIndex typeIdx, UDate date, |
| UBool commonlyUsedOnly, UnicodeString& result) const; |
| |
| /* |
| * Private method to get a generic string, with fallback logic involved, |
| * that is, |
| * |
| * 1. If a generic non-location string is avaiable for the zone, return it. |
| * 2. If a generic non-location string is associated with a metazone and |
| * the zone never use daylight time around the given date, use the standard |
| * string (if available). |
| * |
| * Note: In CLDR1.5.1, the same localization is used for generic and standard. |
| * In this case, we do not use the standard string and do the rest. |
| * |
| * 3. If a generic non-location string is associated with a metazone and |
| * the offset at the given time is different from the preferred zone for the |
| * current locale, then return the generic partial location string (if avaiable) |
| * 4. If a generic non-location string is not available, use generic location |
| * string. |
| */ |
| UnicodeString& getGenericString(const Calendar &cal, UBool isShort, UBool commonlyUsedOnly, |
| UnicodeString &result, UErrorCode &status) const; |
| |
| /* |
| * Private method to get a generic partial location string |
| */ |
| UnicodeString& getGenericPartialLocationString(const UnicodeString &tzid, UBool isShort, |
| UDate date, UBool commonlyUsedOnly, UnicodeString &result) const; |
| |
| /* |
| * Find a prefix matching time zone for the given zone string types. |
| * @param text The text contains a time zone string |
| * @param start The start index within the text |
| * @param types The bit mask representing a set of requested types |
| * @param matchLength Receives the match length |
| * @param status |
| * @return If any zone string matched for the requested types, returns a |
| * ZoneStringInfo for the longest match. If no matches are found for |
| * the requested types, returns a ZoneStringInfo for the longest match |
| * for any other types. If nothing matches at all, returns null. |
| */ |
| const ZoneStringInfo* find(const UnicodeString &text, int32_t start, int32_t types, |
| int32_t &matchLength, UErrorCode &status) const; |
| const ZoneStringInfo* subFind(const UnicodeString &text, int32_t start, int32_t types, |
| int32_t &matchLength, UErrorCode &status) const; |
| |
| UnicodeString& getRegion(UnicodeString ®ion) const; |
| |
| static MessageFormat* getFallbackFormat(const Locale &locale, UErrorCode &status); |
| static MessageFormat* getRegionFormat(const Locale &locale, UErrorCode &status); |
| const UChar* getZoneStringFromBundle(const UResourceBundle *zoneitem, const char *key); |
| static UBool isCommonlyUsed(const UResourceBundle *zoneitem); |
| static UnicodeString& getLocalizedCountry(const UnicodeString &countryCode, const Locale &locale, |
| UnicodeString &displayCountry); |
| }; |
| |
| inline UnicodeString& |
| ZoneStringFormat::getLongStandard(const UnicodeString &tzid, UDate date, |
| UnicodeString &result) const { |
| return getString(tzid, ZSIDX_LONG_STANDARD, date, FALSE /* not used */, result); |
| } |
| |
| inline UnicodeString& |
| ZoneStringFormat::getLongDaylight(const UnicodeString &tzid, UDate date, |
| UnicodeString &result) const { |
| return getString(tzid, ZSIDX_LONG_DAYLIGHT, date, FALSE /* not used */, result); |
| } |
| |
| inline UnicodeString& |
| ZoneStringFormat::getLongGenericNonLocation(const UnicodeString &tzid, UDate date, |
| UnicodeString &result) const { |
| return getString(tzid, ZSIDX_LONG_GENERIC, date, FALSE /* not used */, result); |
| } |
| |
| inline UnicodeString& |
| ZoneStringFormat::getLongGenericPartialLocation(const UnicodeString &tzid, UDate date, |
| UnicodeString &result) const { |
| return getGenericPartialLocationString(tzid, FALSE, date, FALSE /* not used */, result); |
| } |
| |
| inline UnicodeString& |
| ZoneStringFormat::getShortStandard(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly, |
| UnicodeString &result) const { |
| return getString(tzid, ZSIDX_SHORT_STANDARD, date, commonlyUsedOnly, result); |
| } |
| |
| inline UnicodeString& |
| ZoneStringFormat::getShortDaylight(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly, |
| UnicodeString &result) const { |
| return getString(tzid, ZSIDX_SHORT_DAYLIGHT, date, commonlyUsedOnly, result); |
| } |
| |
| inline UnicodeString& |
| ZoneStringFormat::getShortGenericNonLocation(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly, |
| UnicodeString &result) const { |
| return getString(tzid, ZSIDX_SHORT_GENERIC, date, commonlyUsedOnly, result); |
| } |
| |
| inline UnicodeString& |
| ZoneStringFormat::getShortGenericPartialLocation(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly, |
| UnicodeString &result) const { |
| return getGenericPartialLocationString(tzid, TRUE, date, commonlyUsedOnly, result); |
| } |
| |
| inline UnicodeString& |
| ZoneStringFormat::getGenericLocation(const UnicodeString &tzid, UnicodeString &result) const { |
| return getString(tzid, ZSIDX_LOCATION, 0 /*not used*/, FALSE /*not used*/, result); |
| } |
| |
| |
| /* |
| * ZoneStrings is a container of localized zone strings used by ZoneStringFormat |
| */ |
| class ZoneStrings : public UMemory { |
| public: |
| ZoneStrings(UnicodeString *strings, |
| int32_t stringsCount, |
| UBool commonlyUsed, |
| UnicodeString **genericPartialLocationStrings, |
| int32_t genericRowCount, |
| int32_t genericColCount, |
| ZSFStringPool &sp, |
| UErrorCode &status); |
| virtual ~ZoneStrings(); |
| |
| UnicodeString& getString(int32_t typeIdx, UnicodeString &result) const; |
| inline UBool isShortFormatCommonlyUsed(void) const; |
| UnicodeString& getGenericPartialLocationString(const UnicodeString &mzid, UBool isShort, |
| UBool commonlyUsedOnly, UnicodeString &result) const; |
| |
| private: |
| const UChar **fStrings; |
| int32_t fStringsCount; |
| UBool fIsCommonlyUsed; |
| const UChar * **fGenericPartialLocationStrings; |
| int32_t fGenericPartialLocationRowCount; |
| int32_t fGenericPartialLocationColCount; |
| }; |
| |
| inline UBool |
| ZoneStrings::isShortFormatCommonlyUsed(void) const { |
| return fIsCommonlyUsed; |
| } |
| |
| /* |
| * ZoneStringSearchResultHandler is an implementation of |
| * TextTrieMapSearchHandler. This class is used by ZoneStringFormat |
| * for collecting search results for localized zone strings. |
| */ |
| class ZoneStringSearchResultHandler : public TextTrieMapSearchResultHandler { |
| public: |
| ZoneStringSearchResultHandler(UErrorCode &status); |
| virtual ~ZoneStringSearchResultHandler(); |
| |
| virtual UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status); |
| int32_t countMatches(void); |
| const ZoneStringInfo* getMatch(int32_t index, int32_t &matchLength); |
| void clear(void); |
| |
| private: |
| UVector fResults; |
| int32_t fMatchLen[ZSIDX_COUNT]; |
| }; |
| |
| |
| /* |
| * ZoneStringFormat cache implementation |
| */ |
| class ZSFCacheEntry : public UMemory { |
| public: |
| ~ZSFCacheEntry(); |
| |
| void delRef(void); |
| const ZoneStringFormat* getZoneStringFormat(void); |
| |
| private: |
| friend class ZSFCache; |
| |
| ZSFCacheEntry(const Locale &locale, ZoneStringFormat *zsf, ZSFCacheEntry *next); |
| |
| Locale fLocale; |
| ZoneStringFormat *fZoneStringFormat; |
| ZSFCacheEntry *fNext; |
| int32_t fRefCount; |
| }; |
| |
| class SafeZoneStringFormatPtr : public UMemory { |
| public: |
| ~SafeZoneStringFormatPtr(); |
| const ZoneStringFormat* get() const; |
| |
| private: |
| friend class ZSFCache; |
| |
| SafeZoneStringFormatPtr(ZSFCacheEntry *cacheEntry); |
| |
| ZSFCacheEntry *fCacheEntry; |
| }; |
| |
| class ZSFCache : public UMemory { |
| public: |
| ZSFCache(int32_t capacity); |
| ~ZSFCache(); |
| |
| SafeZoneStringFormatPtr* get(const Locale &locale, UErrorCode &status); |
| |
| private: |
| int32_t fCapacity; |
| ZSFCacheEntry *fFirst; |
| }; |
| |
| U_NAMESPACE_END |
| |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
| |
| #endif // ZSTRFMT_H |
