/*
*******************************************************************************
* 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