icuSources/i18n/zstrfmt.h

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2007-2010, International Business Machines Corporation and    *
   4 * others. All Rights Reserved.                                                *
   5 *******************************************************************************
   6 */
   7 #ifndef ZSTRFMT_H
   8 #define ZSTRFMT_H
   9
  10 #include "unicode/utypes.h"
  11
  12 #if !UCONFIG_NO_FORMATTING
  13
  14 #include "unicode/unistr.h"
  15 #include "unicode/calendar.h"
  16 #include "uhash.h"
  17 #include "uvector.h"
  18
  19 U_NAMESPACE_BEGIN
  20
  21 /*
  22  * Character node used by TextTrieMap
  23  */
  24 struct CharacterNode {
  25     // No constructor or destructor.
  26     // We malloc and free an uninitalized array of CharacterNode objects
  27     // and clear and delete them ourselves.
  28
  29     void clear();
  30     void deleteValues();
  31
  32     void addValue(void *value, UErrorCode &status);
  33     inline UBool hasValues() const;
  34     inline int32_t countValues() const;
  35     inline const void *getValue(int32_t index) const;
  36
  37     void     *fValues;      // Union of one single value vs. UVector of values.
  38     UChar    fCharacter;    // UTF-16 code unit.
  39     uint16_t fFirstChild;   // 0 if no children.
  40     uint16_t fNextSibling;  // 0 terminates the list.
  41     UBool    fHasValuesVector;
  42     UBool    fPadding;
  43
  44     // No value:   fValues == NULL               and  fHasValuesVector == FALSE
  45     // One value:  fValues == value              and  fHasValuesVector == FALSE
  46     // >=2 values: fValues == UVector of values  and  fHasValuesVector == TRUE
  47 };
  48
  49 inline UBool CharacterNode::hasValues() const {
  50     return (UBool)(fValues != NULL);
  51 }
  52
  53 inline int32_t CharacterNode::countValues() const {
  54     return
  55         fValues == NULL ? 0 :
  56         !fHasValuesVector ? 1 :
  57         ((const UVector *)fValues)->size();
  58 }
  59
  60 inline const void *CharacterNode::getValue(int32_t index) const {
  61     if (!fHasValuesVector) {
  62         return fValues;  // Assume index == 0.
  63     } else {
  64         return ((const UVector *)fValues)->elementAt(index);
  65     }
  66 }
  67
  68 /*
  69  * Search result handler callback interface used by TextTrieMap search.
  70  */
  71 class TextTrieMapSearchResultHandler : public UMemory {
  72 public:
  73     virtual UBool handleMatch(int32_t matchLength,
  74                               const CharacterNode *node, UErrorCode& status) = 0;
  75     virtual ~TextTrieMapSearchResultHandler(); //added to avoid warning
  76 };
  77
  78
  79 /*
  80  * ZSFStringPool   Pool of (UChar *) strings.  Provides for sharing of repeated
  81  *                 strings within ZoneStringFormats.
  82  */
  83 class ZSFStringPoolChunk;
  84 class ZSFStringPool: public UMemory {
  85   public:
  86     ZSFStringPool(UErrorCode &status);
  87     ~ZSFStringPool();
  88
  89     /* Get the pooled string that is equal to the supplied string s.
  90      * Copy the string into the pool if it is not already present.
  91      *
  92      * Life time of the returned string is that of the pool.
  93      */
  94     const UChar *get(const UChar *s, UErrorCode &status);
  95
  96     /* Get the pooled string that is equal to the supplied string s.
  97      * Copy the string into the pool if it is not already present.
  98      */
  99     const UChar *get(const UnicodeString &s, UErrorCode &status);
 100
 101     /* Adopt a string into the pool, without copying it.
 102      * Used for strings from resource bundles, which will persist without copying.
 103      */
 104     const UChar *adopt(const UChar *s, UErrorCode &status);
 105
 106     /* Freeze the string pool.  Discards the hash table that is used
 107      * for looking up a string.  All pointers to pooled strings remain valid.
 108      */
 109     void freeze();
 110
 111   private:
 112     ZSFStringPoolChunk   *fChunks;
 113     UHashtable           *fHash;
 114 };
 115
 116
 117 /**
 118  * TextTrieMap is a trie implementation for supporting
 119  * fast prefix match for the string key.
 120  */
 121 class TextTrieMap : public UMemory {
 122 public:
 123     TextTrieMap(UBool ignoreCase);
 124     virtual ~TextTrieMap();
 125
 126     void put(const UnicodeString &key, void *value, ZSFStringPool &sp, UErrorCode &status);
 127     void search(const UnicodeString &text, int32_t start,
 128         TextTrieMapSearchResultHandler *handler, UErrorCode& status) const;
 129     int32_t isEmpty() const;
 130
 131 private:
 132     UBool           fIgnoreCase;
 133     CharacterNode   *fNodes;
 134     int32_t         fNodesCapacity;
 135     int32_t         fNodesCount;
 136
 137     UVector         *fLazyContents;
 138     UBool           fIsEmpty;
 139
 140     UBool growNodes();
 141     CharacterNode* addChildNode(CharacterNode *parent, UChar c, UErrorCode &status);
 142     CharacterNode* getChildNode(CharacterNode *parent, UChar c) const;
 143
 144     void putImpl(const UnicodeString &key, void *value, UErrorCode &status);
 145     void buildTrie(UErrorCode &status);
 146     void search(CharacterNode *node, const UnicodeString &text, int32_t start,
 147         int32_t index, TextTrieMapSearchResultHandler *handler, UErrorCode &status) const;
 148 };
 149
 150
 151 // Name types, these bit flag are used for zone string lookup
 152 enum TimeZoneTranslationType {
 153     LOCATION        = 0x0001,
 154     GENERIC_LONG    = 0x0002,
 155     GENERIC_SHORT   = 0x0004,
 156     STANDARD_LONG   = 0x0008,
 157     STANDARD_SHORT  = 0x0010,
 158     DAYLIGHT_LONG   = 0x0020,
 159     DAYLIGHT_SHORT  = 0x0040
 160 };
 161
 162 // Name type index, these constants are used for index in the zone strings array.
 163 enum TimeZoneTranslationTypeIndex {
 164     ZSIDX_LOCATION = 0,
 165     ZSIDX_LONG_STANDARD,
 166     ZSIDX_SHORT_STANDARD,
 167     ZSIDX_LONG_DAYLIGHT,
 168     ZSIDX_SHORT_DAYLIGHT,
 169     ZSIDX_LONG_GENERIC,
 170     ZSIDX_SHORT_GENERIC,
 171
 172     ZSIDX_COUNT
 173 };
 174
 175 class MessageFormat;
 176
 177
 178 /*
 179  * ZoneStringInfo is a class holding a localized zone string
 180  * information.
 181  */
 182 class ZoneStringInfo : public UMemory {
 183 public:
 184     virtual ~ZoneStringInfo();
 185
 186     inline UnicodeString& getID(UnicodeString &result) const;
 187     inline UnicodeString& getString(UnicodeString &result) const;
 188     inline UBool isStandard(void) const;
 189     inline UBool isDaylight(void) const;
 190     inline UBool isGeneric(void) const;
 191
 192 private:
 193     friend class ZoneStringFormat;
 194     friend class ZoneStringSearchResultHandler;
 195
 196     ZoneStringInfo(const UnicodeString &id, const UnicodeString &str,
 197                    TimeZoneTranslationType type, ZSFStringPool &sp, UErrorCode &status);
 198
 199     const UChar   *fId;
 200     const UChar   *fStr;
 201     TimeZoneTranslationType fType;
 202 };
 203
 204 inline UnicodeString& ZoneStringInfo::getID(UnicodeString &result) const {
 205     return result.setTo(fId, -1);
 206 }
 207
 208 inline UnicodeString& ZoneStringInfo::getString(UnicodeString &result) const {
 209     return result.setTo(fStr, -1);
 210 }
 211
 212 inline UBool ZoneStringInfo::isStandard(void) const {
 213     return (fType == STANDARD_LONG || fType == STANDARD_SHORT);
 214 }
 215
 216 inline UBool ZoneStringInfo::isDaylight(void) const {
 217     return (fType == DAYLIGHT_LONG || fType == DAYLIGHT_SHORT);
 218 }
 219
 220 inline UBool ZoneStringInfo::isGeneric(void) const {
 221     return (fType == LOCATION || fType == GENERIC_LONG || fType == GENERIC_SHORT);
 222 }
 223
 224 class SafeZoneStringFormatPtr;
 225
 226 class ZoneStringFormat : public UMemory {
 227 public:
 228     ZoneStringFormat(const UnicodeString* const* strings, int32_t rowCount, int32_t columnCount, UErrorCode &status);
 229     ZoneStringFormat(const Locale& locale, UErrorCode &status);
 230     virtual ~ZoneStringFormat();
 231
 232     /* Gets zone string format from cache if available, create it if not cached. */
 233     static SafeZoneStringFormatPtr* getZoneStringFormat(const Locale& locale, UErrorCode &status);
 234
 235     /*
 236      * Create a snapshot of old zone strings array for the given date
 237      */
 238     UnicodeString** createZoneStringsArray(UDate date, int32_t &rowCount, int32_t &colCount, UErrorCode &status) const;
 239
 240     /* TODO:  There is no implementation for this function.  Delete declaration? */
 241     const UnicodeString** getZoneStrings(int32_t &rowCount, int32_t &columnCount) const;
 242
 243     UnicodeString& getSpecificLongString(const Calendar &cal,
 244         UnicodeString &result, UErrorCode &status) const;
 245
 246     UnicodeString& getSpecificShortString(const Calendar &cal,
 247         UBool commonlyUsedOnly, UnicodeString &result, UErrorCode &status) const;
 248
 249     UnicodeString& getGenericLongString(const Calendar &cal,
 250         UnicodeString &result, UErrorCode &status) const;
 251
 252     UnicodeString& getGenericShortString(const Calendar &cal,
 253         UBool commonlyUsedOnly, UnicodeString &result, UErrorCode &status) const;
 254
 255     UnicodeString& getGenericLocationString(const Calendar &cal,
 256         UnicodeString &result, UErrorCode &status) const;
 257
 258     const ZoneStringInfo* findSpecificLong(const UnicodeString &text, int32_t start,
 259         int32_t &matchLength, UErrorCode &status) const;
 260     const ZoneStringInfo* findSpecificShort(const UnicodeString &text, int32_t start,
 261         int32_t &matchLength, UErrorCode &status) const;
 262     const ZoneStringInfo* findGenericLong(const UnicodeString &text, int32_t start,
 263         int32_t &matchLength, UErrorCode &status) const;
 264     const ZoneStringInfo* findGenericShort(const UnicodeString &text, int32_t start,
 265         int32_t &matchLength, UErrorCode &status) const;
 266     const ZoneStringInfo* findGenericLocation(const UnicodeString &text, int32_t start,
 267         int32_t &matchLength, UErrorCode &status) const;
 268
 269     // Following APIs are not used by SimpleDateFormat, but public for testing purpose
 270     inline UnicodeString& getLongStandard(const UnicodeString &tzid, UDate date,
 271         UnicodeString &result) const;
 272     inline UnicodeString& getLongDaylight(const UnicodeString &tzid, UDate date,
 273         UnicodeString &result) const;
 274     inline UnicodeString& getLongGenericNonLocation(const UnicodeString &tzid, UDate date,
 275         UnicodeString &result) const;
 276     inline UnicodeString& getLongGenericPartialLocation(const UnicodeString &tzid, UDate date,
 277         UnicodeString &result) const;
 278     inline UnicodeString& getShortStandard(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly,
 279         UnicodeString &result) const;
 280     inline UnicodeString& getShortDaylight(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly,
 281         UnicodeString &result) const;
 282     inline UnicodeString& getShortGenericNonLocation(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly,
 283         UnicodeString &result) const;
 284     inline UnicodeString& getShortGenericPartialLocation(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly,
 285         UnicodeString &result) const;
 286     inline UnicodeString& getGenericLocation(const UnicodeString &tzid, UnicodeString &result) const;
 287
 288 private:
 289     Locale           fLocale;
 290     UHashtable      *fTzidToStrings;
 291     UHashtable      *fMzidToStrings;
 292
 293     TextTrieMap      fZoneStringsTrie;
 294     ZSFStringPool    fStringPool;
 295
 296     UResourceBundle *fZoneStringsArray;
 297     UResourceBundle *fMetazoneItem;
 298     UResourceBundle *fZoneItem;
 299
 300         UBool                    fIsFullyLoaded;
 301
 302         void loadZone(const UnicodeString &utzid, UErrorCode &status);
 303         void addSingleZone(UnicodeString &utzid, UErrorCode &status);
 304         void loadFull(UErrorCode &status);
 305
 306
 307     /*
 308      * Private method to get a zone string except generic partial location types.
 309      */
 310     UnicodeString& getString(const UnicodeString &tzid, TimeZoneTranslationTypeIndex typeIdx, UDate date,
 311         UBool commonlyUsedOnly, UnicodeString& result) const;
 312
 313     /*
 314      * Private method to get a generic string, with fallback logic involved,
 315      * that is,
 316      *
 317      * 1. If a generic non-location string is avaiable for the zone, return it.
 318      * 2. If a generic non-location string is associated with a metazone and
 319      *    the zone never use daylight time around the given date, use the standard
 320      *    string (if available).
 321      *
 322      *    Note: In CLDR1.5.1, the same localization is used for generic and standard.
 323      *    In this case, we do not use the standard string and do the rest.
 324      *
 325      * 3. If a generic non-location string is associated with a metazone and
 326      *    the offset at the given time is different from the preferred zone for the
 327      *    current locale, then return the generic partial location string (if avaiable)
 328      * 4. If a generic non-location string is not available, use generic location
 329      *    string.
 330      */
 331     UnicodeString& getGenericString(const Calendar &cal, UBool isShort, UBool commonlyUsedOnly,
 332         UnicodeString &result, UErrorCode &status) const;
 333
 334     /*
 335      * Private method to get a generic partial location string
 336      */
 337     UnicodeString& getGenericPartialLocationString(const UnicodeString &tzid, UBool isShort,
 338         UDate date, UBool commonlyUsedOnly, UnicodeString &result) const;
 339
 340     /*
 341      * Find a prefix matching time zone for the given zone string types.
 342      * @param text The text contains a time zone string
 343      * @param start The start index within the text
 344      * @param types The bit mask representing a set of requested types
 345      * @param matchLength Receives the match length
 346      * @param status
 347      * @return If any zone string matched for the requested types, returns a
 348      * ZoneStringInfo for the longest match.  If no matches are found for
 349      * the requested types, returns a ZoneStringInfo for the longest match
 350      * for any other types.  If nothing matches at all, returns null.
 351      */
 352     const ZoneStringInfo* find(const UnicodeString &text, int32_t start, int32_t types,
 353         int32_t &matchLength, UErrorCode &status) const;
 354         const ZoneStringInfo* subFind(const UnicodeString &text, int32_t start, int32_t types,
 355                        int32_t &matchLength, UErrorCode &status) const;
 356
 357     UnicodeString& getRegion(UnicodeString &region) const;
 358
 359     static MessageFormat* getFallbackFormat(const Locale &locale, UErrorCode &status);
 360     static MessageFormat* getRegionFormat(const Locale &locale, UErrorCode &status);
 361     const UChar* getZoneStringFromBundle(const UResourceBundle *zoneitem, const char *key);
 362     static UBool isCommonlyUsed(const UResourceBundle *zoneitem);
 363     static UnicodeString& getLocalizedCountry(const UnicodeString &countryCode, const Locale &locale,
 364         UnicodeString &displayCountry);
 365 };
 366
 367 inline UnicodeString&
 368 ZoneStringFormat::getLongStandard(const UnicodeString &tzid, UDate date,
 369                                   UnicodeString &result) const {
 370     return getString(tzid, ZSIDX_LONG_STANDARD, date, FALSE /* not used */, result);
 371 }
 372
 373 inline UnicodeString&
 374 ZoneStringFormat::getLongDaylight(const UnicodeString &tzid, UDate date,
 375                                   UnicodeString &result) const {
 376     return getString(tzid, ZSIDX_LONG_DAYLIGHT, date, FALSE /* not used */, result);
 377 }
 378
 379 inline UnicodeString&
 380 ZoneStringFormat::getLongGenericNonLocation(const UnicodeString &tzid, UDate date,
 381                                             UnicodeString &result) const {
 382     return getString(tzid, ZSIDX_LONG_GENERIC, date, FALSE /* not used */, result);
 383 }
 384
 385 inline UnicodeString&
 386 ZoneStringFormat::getLongGenericPartialLocation(const UnicodeString &tzid, UDate date,
 387                                                 UnicodeString &result) const {
 388     return getGenericPartialLocationString(tzid, FALSE, date, FALSE /* not used */, result);
 389 }
 390
 391 inline UnicodeString&
 392 ZoneStringFormat::getShortStandard(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly,
 393                                    UnicodeString &result) const {
 394     return getString(tzid, ZSIDX_SHORT_STANDARD, date, commonlyUsedOnly, result);
 395 }
 396
 397 inline UnicodeString&
 398 ZoneStringFormat::getShortDaylight(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly,
 399                                    UnicodeString &result) const {
 400     return getString(tzid, ZSIDX_SHORT_DAYLIGHT, date, commonlyUsedOnly, result);
 401 }
 402
 403 inline UnicodeString&
 404 ZoneStringFormat::getShortGenericNonLocation(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly,
 405                                              UnicodeString &result) const {
 406     return getString(tzid, ZSIDX_SHORT_GENERIC, date, commonlyUsedOnly, result);
 407 }
 408
 409 inline UnicodeString&
 410 ZoneStringFormat::getShortGenericPartialLocation(const UnicodeString &tzid, UDate date, UBool commonlyUsedOnly,
 411                                                  UnicodeString &result) const {
 412     return getGenericPartialLocationString(tzid, TRUE, date, commonlyUsedOnly, result);
 413 }
 414
 415 inline UnicodeString&
 416 ZoneStringFormat::getGenericLocation(const UnicodeString &tzid, UnicodeString &result) const {
 417     return getString(tzid, ZSIDX_LOCATION, 0 /*not used*/, FALSE /*not used*/, result);
 418 }
 419
 420
 421 /*
 422  * ZoneStrings is a container of localized zone strings used by ZoneStringFormat
 423  */
 424 class ZoneStrings : public UMemory {
 425 public:
 426     ZoneStrings(UnicodeString *strings,
 427                 int32_t        stringsCount,
 428                 UBool          commonlyUsed,
 429                 UnicodeString **genericPartialLocationStrings,
 430                 int32_t        genericRowCount,
 431                 int32_t        genericColCount,
 432                 ZSFStringPool &sp,
 433                 UErrorCode    &status);
 434     virtual         ~ZoneStrings();
 435
 436     UnicodeString&   getString(int32_t typeIdx, UnicodeString &result) const;
 437     inline UBool     isShortFormatCommonlyUsed(void) const;
 438     UnicodeString&   getGenericPartialLocationString(const UnicodeString &mzid, UBool isShort,
 439                                         UBool commonlyUsedOnly, UnicodeString &result) const;
 440
 441 private:
 442     const UChar   **fStrings;
 443     int32_t         fStringsCount;
 444     UBool           fIsCommonlyUsed;
 445     const UChar * **fGenericPartialLocationStrings;
 446     int32_t         fGenericPartialLocationRowCount;
 447     int32_t         fGenericPartialLocationColCount;
 448 };
 449
 450 inline UBool
 451 ZoneStrings::isShortFormatCommonlyUsed(void) const {
 452     return fIsCommonlyUsed;
 453 }
 454
 455 /*
 456  * ZoneStringSearchResultHandler is an implementation of
 457  * TextTrieMapSearchHandler.  This class is used by ZoneStringFormat
 458  * for collecting search results for localized zone strings.
 459  */
 460 class ZoneStringSearchResultHandler : public TextTrieMapSearchResultHandler {
 461 public:
 462     ZoneStringSearchResultHandler(UErrorCode &status);
 463     virtual ~ZoneStringSearchResultHandler();
 464
 465     virtual UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status);
 466     int32_t countMatches(void);
 467     const ZoneStringInfo* getMatch(int32_t index, int32_t &matchLength);
 468     void clear(void);
 469
 470 private:
 471     UVector fResults;
 472     int32_t fMatchLen[ZSIDX_COUNT];
 473 };
 474
 475
 476 /*
 477  * ZoneStringFormat cache implementation
 478  */
 479 class ZSFCacheEntry : public UMemory {
 480 public:
 481     ~ZSFCacheEntry();
 482
 483     void delRef(void);
 484     const ZoneStringFormat* getZoneStringFormat(void);
 485
 486 private:
 487     friend class ZSFCache;
 488
 489     ZSFCacheEntry(const Locale &locale, ZoneStringFormat *zsf, ZSFCacheEntry *next);
 490
 491     Locale              fLocale;
 492     ZoneStringFormat    *fZoneStringFormat;
 493     ZSFCacheEntry       *fNext;
 494     int32_t             fRefCount;
 495 };
 496
 497 class SafeZoneStringFormatPtr : public UMemory {
 498 public:
 499     ~SafeZoneStringFormatPtr();
 500     const ZoneStringFormat* get() const;
 501
 502 private:
 503     friend class ZSFCache;
 504
 505     SafeZoneStringFormatPtr(ZSFCacheEntry *cacheEntry);
 506
 507     ZSFCacheEntry   *fCacheEntry;
 508 };
 509
 510 class ZSFCache : public UMemory {
 511 public:
 512     ZSFCache(int32_t capacity);
 513     ~ZSFCache();
 514
 515     SafeZoneStringFormatPtr* get(const Locale &locale, UErrorCode &status);
 516
 517 private:
 518     int32_t         fCapacity;
 519     ZSFCacheEntry   *fFirst;
 520 };
 521
 522 U_NAMESPACE_END
 523
 524 #endif /* #if !UCONFIG_NO_FORMATTING */
 525
 526 #endif // ZSTRFMT_H