| OLD | NEW |
|---|
| (Empty) | |
| 1 /* |
| 2 ******************************************************************************* |
| 3 * Copyright (C) 1997-2009, International Business Machines Corporation and * |
| 4 * others. All Rights Reserved. * |
| 5 ******************************************************************************* |
| 6 * |
| 7 * File DTFMTSYM.CPP |
| 8 * |
| 9 * Modification History: |
| 10 * |
| 11 * Date Name Description |
| 12 * 02/19/97 aliu Converted from java. |
| 13 * 07/21/98 stephen Added getZoneIndex |
| 14 * Changed weekdays/short weekdays to be one-based |
| 15 * 06/14/99 stephen Removed SimpleDateFormat::fgTimeZoneDataSuffix |
| 16 * 11/16/99 weiv Added 'Y' and 'e' to fgPatternChars |
| 17 * 03/27/00 weiv Keeping resource bundle around! |
| 18 * 06/30/05 emmons Added eraNames, narrow month/day, standalone context |
| 19 * 10/12/05 emmons Added setters for eraNames, month/day by width/conte
xt |
| 20 ******************************************************************************* |
| 21 */ |
| 22 #include "unicode/utypes.h" |
| 23 |
| 24 #if !UCONFIG_NO_FORMATTING |
| 25 #include "unicode/ustring.h" |
| 26 #include "unicode/dtfmtsym.h" |
| 27 #include "unicode/smpdtfmt.h" |
| 28 #include "unicode/msgfmt.h" |
| 29 #include "cpputils.h" |
| 30 #include "ucln_in.h" |
| 31 #include "umutex.h" |
| 32 #include "cmemory.h" |
| 33 #include "cstring.h" |
| 34 #include "locbased.h" |
| 35 #include "gregoimp.h" |
| 36 #include "hash.h" |
| 37 #include "uresimp.h" |
| 38 #include "zstrfmt.h" |
| 39 #include "ureslocs.h" |
| 40 |
| 41 // ***************************************************************************** |
| 42 // class DateFormatSymbols |
| 43 // ***************************************************************************** |
| 44 |
| 45 /** |
| 46 * These are static arrays we use only in the case where we have no |
| 47 * resource data. |
| 48 */ |
| 49 |
| 50 #define PATTERN_CHARS_LEN 30 |
| 51 |
| 52 /** |
| 53 * Unlocalized date-time pattern characters. For example: 'y', 'd', etc. All |
| 54 * locales use the same these unlocalized pattern characters. |
| 55 */ |
| 56 static const UChar gPatternChars[] = { |
| 57 // GyMdkHmsSEDFwWahKzYeugAZvcLQqV |
| 58 0x47, 0x79, 0x4D, 0x64, 0x6B, 0x48, 0x6D, 0x73, 0x53, 0x45, |
| 59 0x44, 0x46, 0x77, 0x57, 0x61, 0x68, 0x4B, 0x7A, 0x59, 0x65, |
| 60 0x75, 0x67, 0x41, 0x5A, 0x76, 0x63, 0x4c, 0x51, 0x71, 0x56, 0 |
| 61 }; |
| 62 |
| 63 /* length of an array */ |
| 64 #define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0])) |
| 65 |
| 66 //------------------------------------------------------ |
| 67 // Strings of last resort. These are only used if we have no resource |
| 68 // files. They aren't designed for actual use, just for backup. |
| 69 |
| 70 // These are the month names and abbreviations of last resort. |
| 71 static const UChar gLastResortMonthNames[13][3] = |
| 72 { |
| 73 {0x0030, 0x0031, 0x0000}, /* "01" */ |
| 74 {0x0030, 0x0032, 0x0000}, /* "02" */ |
| 75 {0x0030, 0x0033, 0x0000}, /* "03" */ |
| 76 {0x0030, 0x0034, 0x0000}, /* "04" */ |
| 77 {0x0030, 0x0035, 0x0000}, /* "05" */ |
| 78 {0x0030, 0x0036, 0x0000}, /* "06" */ |
| 79 {0x0030, 0x0037, 0x0000}, /* "07" */ |
| 80 {0x0030, 0x0038, 0x0000}, /* "08" */ |
| 81 {0x0030, 0x0039, 0x0000}, /* "09" */ |
| 82 {0x0031, 0x0030, 0x0000}, /* "10" */ |
| 83 {0x0031, 0x0031, 0x0000}, /* "11" */ |
| 84 {0x0031, 0x0032, 0x0000}, /* "12" */ |
| 85 {0x0031, 0x0033, 0x0000} /* "13" */ |
| 86 }; |
| 87 |
| 88 // These are the weekday names and abbreviations of last resort. |
| 89 static const UChar gLastResortDayNames[8][2] = |
| 90 { |
| 91 {0x0030, 0x0000}, /* "0" */ |
| 92 {0x0031, 0x0000}, /* "1" */ |
| 93 {0x0032, 0x0000}, /* "2" */ |
| 94 {0x0033, 0x0000}, /* "3" */ |
| 95 {0x0034, 0x0000}, /* "4" */ |
| 96 {0x0035, 0x0000}, /* "5" */ |
| 97 {0x0036, 0x0000}, /* "6" */ |
| 98 {0x0037, 0x0000} /* "7" */ |
| 99 }; |
| 100 |
| 101 // These are the quarter names and abbreviations of last resort. |
| 102 static const UChar gLastResortQuarters[4][2] = |
| 103 { |
| 104 {0x0031, 0x0000}, /* "1" */ |
| 105 {0x0032, 0x0000}, /* "2" */ |
| 106 {0x0033, 0x0000}, /* "3" */ |
| 107 {0x0034, 0x0000}, /* "4" */ |
| 108 }; |
| 109 |
| 110 // These are the am/pm and BC/AD markers of last resort. |
| 111 static const UChar gLastResortAmPmMarkers[2][3] = |
| 112 { |
| 113 {0x0041, 0x004D, 0x0000}, /* "AM" */ |
| 114 {0x0050, 0x004D, 0x0000} /* "PM" */ |
| 115 }; |
| 116 |
| 117 static const UChar gLastResortEras[2][3] = |
| 118 { |
| 119 {0x0042, 0x0043, 0x0000}, /* "BC" */ |
| 120 {0x0041, 0x0044, 0x0000} /* "AD" */ |
| 121 }; |
| 122 |
| 123 |
| 124 // These are the zone strings of last resort. |
| 125 static const UChar gLastResortZoneStrings[7][4] = |
| 126 { |
| 127 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ |
| 128 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ |
| 129 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ |
| 130 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ |
| 131 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ |
| 132 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ |
| 133 {0x0047, 0x004D, 0x0054, 0x0000} /* "GMT" */ |
| 134 }; |
| 135 |
| 136 static const UChar gLastResortGmtFormat[] = |
| 137 {0x0047, 0x004D, 0x0054, 0x007B, 0x0030, 0x007D, 0x0000}; /* GMT{0} */ |
| 138 |
| 139 static const UChar gLastResortGmtHourFormats[4][10] = |
| 140 { |
| 141 {0x002D, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0x0
000}, /* -HH:mm:ss */ |
| 142 {0x002D, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x0000, 0x0000, 0x0000, 0x0
000}, /* -HH:mm */ |
| 143 {0x002B, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0x0
000}, /* +HH:mm:ss */ |
| 144 {0x002B, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x0000, 0x0000, 0x0000, 0x0
000} /* +HH:mm */ |
| 145 }; |
| 146 |
| 147 /* Sizes for the last resort string arrays */ |
| 148 typedef enum LastResortSize { |
| 149 kMonthNum = 13, |
| 150 kMonthLen = 3, |
| 151 |
| 152 kDayNum = 8, |
| 153 kDayLen = 2, |
| 154 |
| 155 kAmPmNum = 2, |
| 156 kAmPmLen = 3, |
| 157 |
| 158 kQuarterNum = 4, |
| 159 kQuarterLen = 2, |
| 160 |
| 161 kEraNum = 2, |
| 162 kEraLen = 3, |
| 163 |
| 164 kZoneNum = 5, |
| 165 kZoneLen = 4, |
| 166 |
| 167 kGmtHourNum = 4, |
| 168 kGmtHourLen = 10 |
| 169 } LastResortSize; |
| 170 |
| 171 U_NAMESPACE_BEGIN |
| 172 |
| 173 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateFormatSymbols) |
| 174 |
| 175 #define kSUPPLEMENTAL "supplementalData" |
| 176 |
| 177 /** |
| 178 * These are the tags we expect to see in normal resource bundle files associate
d |
| 179 * with a locale and calendar |
| 180 */ |
| 181 static const char gErasTag[]="eras"; |
| 182 static const char gMonthNamesTag[]="monthNames"; |
| 183 static const char gDayNamesTag[]="dayNames"; |
| 184 static const char gNamesWideTag[]="wide"; |
| 185 static const char gNamesAbbrTag[]="abbreviated"; |
| 186 static const char gNamesNarrowTag[]="narrow"; |
| 187 static const char gNamesStandaloneTag[]="stand-alone"; |
| 188 static const char gAmPmMarkersTag[]="AmPmMarkers"; |
| 189 static const char gQuartersTag[]="quarters"; |
| 190 |
| 191 static const char gZoneStringsTag[]="zoneStrings"; |
| 192 static const char gGmtFormatTag[]="gmtFormat"; |
| 193 static const char gHourFormatTag[]="hourFormat"; |
| 194 |
| 195 static const char gLocalPatternCharsTag[]="localPatternChars"; |
| 196 |
| 197 static UMTX LOCK; |
| 198 |
| 199 /** |
| 200 * Jitterbug 2974: MSVC has a bug whereby new X[0] behaves badly. |
| 201 * Work around this. |
| 202 */ |
| 203 static inline UnicodeString* newUnicodeStringArray(size_t count) { |
| 204 return new UnicodeString[count ? count : 1]; |
| 205 } |
| 206 |
| 207 //------------------------------------------------------ |
| 208 |
| 209 DateFormatSymbols::DateFormatSymbols(const Locale& locale, |
| 210 UErrorCode& status) |
| 211 : UObject() |
| 212 { |
| 213 initializeData(locale, NULL, status); |
| 214 } |
| 215 |
| 216 DateFormatSymbols::DateFormatSymbols(UErrorCode& status) |
| 217 : UObject() |
| 218 { |
| 219 initializeData(Locale::getDefault(), NULL, status, TRUE); |
| 220 } |
| 221 |
| 222 |
| 223 DateFormatSymbols::DateFormatSymbols(const Locale& locale, |
| 224 const char *type, |
| 225 UErrorCode& status) |
| 226 : UObject() |
| 227 { |
| 228 initializeData(locale, type, status); |
| 229 } |
| 230 |
| 231 DateFormatSymbols::DateFormatSymbols(const char *type, UErrorCode& status) |
| 232 : UObject() |
| 233 { |
| 234 initializeData(Locale::getDefault(), type, status, TRUE); |
| 235 } |
| 236 |
| 237 DateFormatSymbols::DateFormatSymbols(const DateFormatSymbols& other) |
| 238 : UObject(other) |
| 239 { |
| 240 copyData(other); |
| 241 } |
| 242 |
| 243 void |
| 244 DateFormatSymbols::assignArray(UnicodeString*& dstArray, |
| 245 int32_t& dstCount, |
| 246 const UnicodeString* srcArray, |
| 247 int32_t srcCount) |
| 248 { |
| 249 // assignArray() is only called by copyData(), which in turn implements the |
| 250 // copy constructor and the assignment operator. |
| 251 // All strings in a DateFormatSymbols object are created in one of the follo
wing |
| 252 // three ways that all allow to safely use UnicodeString::fastCopyFrom(): |
| 253 // - readonly-aliases from resource bundles |
| 254 // - readonly-aliases or allocated strings from constants |
| 255 // - safely cloned strings (with owned buffers) from setXYZ() functions |
| 256 // |
| 257 // Note that this is true for as long as DateFormatSymbols can be constructe
d |
| 258 // only from a locale bundle or set via the cloning API, |
| 259 // *and* for as long as all the strings are in *private* fields, preventing |
| 260 // a subclass from creating these strings in an "unsafe" way (with respect t
o fastCopyFrom()). |
| 261 dstCount = srcCount; |
| 262 dstArray = newUnicodeStringArray(srcCount); |
| 263 if(dstArray != NULL) { |
| 264 int32_t i; |
| 265 for(i=0; i<srcCount; ++i) { |
| 266 dstArray[i].fastCopyFrom(srcArray[i]); |
| 267 } |
| 268 } |
| 269 } |
| 270 |
| 271 /** |
| 272 * Create a copy, in fZoneStrings, of the given zone strings array. The |
| 273 * member variables fZoneStringsRowCount and fZoneStringsColCount should |
| 274 * be set already by the caller. |
| 275 */ |
| 276 void |
| 277 DateFormatSymbols::createZoneStrings(const UnicodeString *const * otherStrings) |
| 278 { |
| 279 int32_t row, col; |
| 280 UBool failed = FALSE; |
| 281 |
| 282 fZoneStrings = (UnicodeString **)uprv_malloc(fZoneStringsRowCount * sizeof(U
nicodeString *)); |
| 283 if (fZoneStrings != NULL) { |
| 284 for (row=0; row<fZoneStringsRowCount; ++row) |
| 285 { |
| 286 fZoneStrings[row] = newUnicodeStringArray(fZoneStringsColCount); |
| 287 if (fZoneStrings[row] == NULL) { |
| 288 failed = TRUE; |
| 289 break; |
| 290 } |
| 291 for (col=0; col<fZoneStringsColCount; ++col) { |
| 292 // fastCopyFrom() - see assignArray comments |
| 293 fZoneStrings[row][col].fastCopyFrom(otherStrings[row][col]); |
| 294 } |
| 295 } |
| 296 } |
| 297 // If memory allocation failed, roll back and delete fZoneStrings |
| 298 if (failed) { |
| 299 for (int i = row; i >= 0; i--) { |
| 300 delete[] fZoneStrings[i]; |
| 301 } |
| 302 uprv_free(fZoneStrings); |
| 303 fZoneStrings = NULL; |
| 304 } |
| 305 } |
| 306 |
| 307 /** |
| 308 * Copy all of the other's data to this. |
| 309 */ |
| 310 void |
| 311 DateFormatSymbols::copyData(const DateFormatSymbols& other) { |
| 312 assignArray(fEras, fErasCount, other.fEras, other.fErasCount); |
| 313 assignArray(fEraNames, fEraNamesCount, other.fEraNames, other.fEraNamesCount
); |
| 314 assignArray(fNarrowEras, fNarrowErasCount, other.fNarrowEras, other.fNarrowE
rasCount); |
| 315 assignArray(fMonths, fMonthsCount, other.fMonths, other.fMonthsCount); |
| 316 assignArray(fShortMonths, fShortMonthsCount, other.fShortMonths, other.fShor
tMonthsCount); |
| 317 assignArray(fNarrowMonths, fNarrowMonthsCount, other.fNarrowMonths, other.fN
arrowMonthsCount); |
| 318 assignArray(fStandaloneMonths, fStandaloneMonthsCount, other.fStandaloneMont
hs, other.fStandaloneMonthsCount); |
| 319 assignArray(fStandaloneShortMonths, fStandaloneShortMonthsCount, other.fStan
daloneShortMonths, other.fStandaloneShortMonthsCount); |
| 320 assignArray(fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, other.fSt
andaloneNarrowMonths, other.fStandaloneNarrowMonthsCount); |
| 321 assignArray(fWeekdays, fWeekdaysCount, other.fWeekdays, other.fWeekdaysCount
); |
| 322 assignArray(fShortWeekdays, fShortWeekdaysCount, other.fShortWeekdays, other
.fShortWeekdaysCount); |
| 323 assignArray(fNarrowWeekdays, fNarrowWeekdaysCount, other.fNarrowWeekdays, ot
her.fNarrowWeekdaysCount); |
| 324 assignArray(fStandaloneWeekdays, fStandaloneWeekdaysCount, other.fStandalone
Weekdays, other.fStandaloneWeekdaysCount); |
| 325 assignArray(fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, other.f
StandaloneShortWeekdays, other.fStandaloneShortWeekdaysCount); |
| 326 assignArray(fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, other
.fStandaloneNarrowWeekdays, other.fStandaloneNarrowWeekdaysCount); |
| 327 assignArray(fAmPms, fAmPmsCount, other.fAmPms, other.fAmPmsCount); |
| 328 assignArray(fQuarters, fQuartersCount, other.fQuarters, other.fQuartersCount
); |
| 329 assignArray(fShortQuarters, fShortQuartersCount, other.fShortQuarters, other
.fShortQuartersCount); |
| 330 assignArray(fStandaloneQuarters, fStandaloneQuartersCount, other.fStandalone
Quarters, other.fStandaloneQuartersCount); |
| 331 assignArray(fStandaloneShortQuarters, fStandaloneShortQuartersCount, other.f
StandaloneShortQuarters, other.fStandaloneShortQuartersCount); |
| 332 fGmtFormat = other.fGmtFormat; |
| 333 assignArray(fGmtHourFormats, fGmtHourFormatsCount, other.fGmtHourFormats, ot
her.fGmtHourFormatsCount); |
| 334 |
| 335 if (other.fZoneStrings != NULL) { |
| 336 fZoneStringsColCount = other.fZoneStringsColCount; |
| 337 fZoneStringsRowCount = other.fZoneStringsRowCount; |
| 338 createZoneStrings((const UnicodeString**)other.fZoneStrings); |
| 339 |
| 340 } else { |
| 341 fZoneStrings = NULL; |
| 342 fZoneStringsColCount = 0; |
| 343 fZoneStringsRowCount = 0; |
| 344 } |
| 345 fZSFLocale = other.fZSFLocale; |
| 346 // Other zone strings data is created on demand |
| 347 fZoneStringFormat = NULL; |
| 348 fLocaleZoneStrings = NULL; |
| 349 fZSFCachePtr = NULL; |
| 350 fZSFLocal = NULL; |
| 351 |
| 352 // fastCopyFrom() - see assignArray comments |
| 353 fLocalPatternChars.fastCopyFrom(other.fLocalPatternChars); |
| 354 } |
| 355 |
| 356 /** |
| 357 * Assignment operator. |
| 358 */ |
| 359 DateFormatSymbols& DateFormatSymbols::operator=(const DateFormatSymbols& other) |
| 360 { |
| 361 dispose(); |
| 362 copyData(other); |
| 363 |
| 364 return *this; |
| 365 } |
| 366 |
| 367 DateFormatSymbols::~DateFormatSymbols() |
| 368 { |
| 369 dispose(); |
| 370 } |
| 371 |
| 372 void DateFormatSymbols::dispose() |
| 373 { |
| 374 if (fEras) delete[] fEras; |
| 375 if (fEraNames) delete[] fEraNames; |
| 376 if (fNarrowEras) delete[] fNarrowEras; |
| 377 if (fMonths) delete[] fMonths; |
| 378 if (fShortMonths) delete[] fShortMonths; |
| 379 if (fNarrowMonths) delete[] fNarrowMonths; |
| 380 if (fStandaloneMonths) delete[] fStandaloneMonths; |
| 381 if (fStandaloneShortMonths) delete[] fStandaloneShortMonths; |
| 382 if (fStandaloneNarrowMonths) delete[] fStandaloneNarrowMonths; |
| 383 if (fWeekdays) delete[] fWeekdays; |
| 384 if (fShortWeekdays) delete[] fShortWeekdays; |
| 385 if (fNarrowWeekdays) delete[] fNarrowWeekdays; |
| 386 if (fStandaloneWeekdays) delete[] fStandaloneWeekdays; |
| 387 if (fStandaloneShortWeekdays) delete[] fStandaloneShortWeekdays; |
| 388 if (fStandaloneNarrowWeekdays) delete[] fStandaloneNarrowWeekdays; |
| 389 if (fAmPms) delete[] fAmPms; |
| 390 if (fQuarters) delete[] fQuarters; |
| 391 if (fShortQuarters) delete[] fShortQuarters; |
| 392 if (fStandaloneQuarters) delete[] fStandaloneQuarters; |
| 393 if (fStandaloneShortQuarters) delete[] fStandaloneShortQuarters; |
| 394 if (fGmtHourFormats) delete[] fGmtHourFormats; |
| 395 |
| 396 disposeZoneStrings(); |
| 397 } |
| 398 |
| 399 void DateFormatSymbols::disposeZoneStrings() |
| 400 { |
| 401 if (fZoneStrings) { |
| 402 for (int32_t row = 0; row < fZoneStringsRowCount; ++row) { |
| 403 delete[] fZoneStrings[row]; |
| 404 } |
| 405 uprv_free(fZoneStrings); |
| 406 } |
| 407 if (fLocaleZoneStrings) { |
| 408 for (int32_t row = 0; row < fZoneStringsRowCount; ++row) { |
| 409 delete[] fLocaleZoneStrings[row]; |
| 410 } |
| 411 uprv_free(fLocaleZoneStrings); |
| 412 } |
| 413 if (fZSFLocal) { |
| 414 delete fZSFLocal; |
| 415 } |
| 416 if (fZSFCachePtr) { |
| 417 delete fZSFCachePtr; |
| 418 } |
| 419 |
| 420 fZoneStrings = NULL; |
| 421 fLocaleZoneStrings = NULL; |
| 422 fZoneStringsRowCount = 0; |
| 423 fZoneStringsColCount = 0; |
| 424 |
| 425 fZoneStringFormat = NULL; |
| 426 fZSFLocal = NULL; |
| 427 fZSFCachePtr = NULL; |
| 428 } |
| 429 |
| 430 UBool |
| 431 DateFormatSymbols::arrayCompare(const UnicodeString* array1, |
| 432 const UnicodeString* array2, |
| 433 int32_t count) |
| 434 { |
| 435 if (array1 == array2) return TRUE; |
| 436 while (count>0) |
| 437 { |
| 438 --count; |
| 439 if (array1[count] != array2[count]) return FALSE; |
| 440 } |
| 441 return TRUE; |
| 442 } |
| 443 |
| 444 UBool |
| 445 DateFormatSymbols::operator==(const DateFormatSymbols& other) const |
| 446 { |
| 447 // First do cheap comparisons |
| 448 if (this == &other) { |
| 449 return TRUE; |
| 450 } |
| 451 if (fErasCount == other.fErasCount && |
| 452 fEraNamesCount == other.fEraNamesCount && |
| 453 fNarrowErasCount == other.fNarrowErasCount && |
| 454 fMonthsCount == other.fMonthsCount && |
| 455 fShortMonthsCount == other.fShortMonthsCount && |
| 456 fNarrowMonthsCount == other.fNarrowMonthsCount && |
| 457 fStandaloneMonthsCount == other.fStandaloneMonthsCount && |
| 458 fStandaloneShortMonthsCount == other.fStandaloneShortMonthsCount && |
| 459 fStandaloneNarrowMonthsCount == other.fStandaloneNarrowMonthsCount && |
| 460 fWeekdaysCount == other.fWeekdaysCount && |
| 461 fShortWeekdaysCount == other.fShortWeekdaysCount && |
| 462 fNarrowWeekdaysCount == other.fNarrowWeekdaysCount && |
| 463 fStandaloneWeekdaysCount == other.fStandaloneWeekdaysCount && |
| 464 fStandaloneShortWeekdaysCount == other.fStandaloneShortWeekdaysCount && |
| 465 fStandaloneNarrowWeekdaysCount == other.fStandaloneNarrowWeekdaysCount &
& |
| 466 fAmPmsCount == other.fAmPmsCount && |
| 467 fQuartersCount == other.fQuartersCount && |
| 468 fShortQuartersCount == other.fShortQuartersCount && |
| 469 fStandaloneQuartersCount == other.fStandaloneQuartersCount && |
| 470 fStandaloneShortQuartersCount == other.fStandaloneShortQuartersCount && |
| 471 fGmtHourFormatsCount == other.fGmtHourFormatsCount && |
| 472 fGmtFormat == other.fGmtFormat) |
| 473 { |
| 474 // Now compare the arrays themselves |
| 475 if (arrayCompare(fEras, other.fEras, fErasCount) && |
| 476 arrayCompare(fEraNames, other.fEraNames, fEraNamesCount) && |
| 477 arrayCompare(fNarrowEras, other.fNarrowEras, fNarrowErasCount) && |
| 478 arrayCompare(fMonths, other.fMonths, fMonthsCount) && |
| 479 arrayCompare(fShortMonths, other.fShortMonths, fShortMonthsCount) && |
| 480 arrayCompare(fNarrowMonths, other.fNarrowMonths, fNarrowMonthsCount)
&& |
| 481 arrayCompare(fStandaloneMonths, other.fStandaloneMonths, fStandalone
MonthsCount) && |
| 482 arrayCompare(fStandaloneShortMonths, other.fStandaloneShortMonths, f
StandaloneShortMonthsCount) && |
| 483 arrayCompare(fStandaloneNarrowMonths, other.fStandaloneNarrowMonths,
fStandaloneNarrowMonthsCount) && |
| 484 arrayCompare(fWeekdays, other.fWeekdays, fWeekdaysCount) && |
| 485 arrayCompare(fShortWeekdays, other.fShortWeekdays, fShortWeekdaysCou
nt) && |
| 486 arrayCompare(fNarrowWeekdays, other.fNarrowWeekdays, fNarrowWeekdays
Count) && |
| 487 arrayCompare(fStandaloneWeekdays, other.fStandaloneWeekdays, fStanda
loneWeekdaysCount) && |
| 488 arrayCompare(fStandaloneShortWeekdays, other.fStandaloneShortWeekday
s, fStandaloneShortWeekdaysCount) && |
| 489 arrayCompare(fStandaloneNarrowWeekdays, other.fStandaloneNarrowWeekd
ays, fStandaloneNarrowWeekdaysCount) && |
| 490 arrayCompare(fAmPms, other.fAmPms, fAmPmsCount) && |
| 491 arrayCompare(fQuarters, other.fQuarters, fQuartersCount) && |
| 492 arrayCompare(fShortQuarters, other.fShortQuarters, fShortQuartersCou
nt) && |
| 493 arrayCompare(fStandaloneQuarters, other.fStandaloneQuarters, fStanda
loneQuartersCount) && |
| 494 arrayCompare(fStandaloneShortQuarters, other.fStandaloneShortQuarter
s, fStandaloneShortQuartersCount) && |
| 495 arrayCompare(fGmtHourFormats, other.fGmtHourFormats, fGmtHourFormats
Count)) |
| 496 { |
| 497 // Compare the contents of fZoneStrings |
| 498 if (fZoneStrings == NULL && other.fZoneStrings == NULL) { |
| 499 if (fZSFLocale == other.fZSFLocale) { |
| 500 return TRUE; |
| 501 } |
| 502 } else if (fZoneStrings != NULL && other.fZoneStrings != NULL) { |
| 503 if (fZoneStringsRowCount == other.fZoneStringsRowCount |
| 504 && fZoneStringsColCount == other.fZoneStringsColCount) { |
| 505 UBool cmpres = TRUE; |
| 506 for (int32_t i = 0; (i < fZoneStringsRowCount) && cmpres; i+
+) { |
| 507 cmpres = arrayCompare(fZoneStrings[i], other.fZoneString
s[i], fZoneStringsColCount); |
| 508 } |
| 509 return cmpres; |
| 510 } |
| 511 } |
| 512 return FALSE; |
| 513 } |
| 514 } |
| 515 return FALSE; |
| 516 } |
| 517 |
| 518 //------------------------------------------------------ |
| 519 |
| 520 const UnicodeString* |
| 521 DateFormatSymbols::getEras(int32_t &count) const |
| 522 { |
| 523 count = fErasCount; |
| 524 return fEras; |
| 525 } |
| 526 |
| 527 const UnicodeString* |
| 528 DateFormatSymbols::getEraNames(int32_t &count) const |
| 529 { |
| 530 count = fEraNamesCount; |
| 531 return fEraNames; |
| 532 } |
| 533 |
| 534 const UnicodeString* |
| 535 DateFormatSymbols::getNarrowEras(int32_t &count) const |
| 536 { |
| 537 count = fNarrowErasCount; |
| 538 return fNarrowEras; |
| 539 } |
| 540 |
| 541 const UnicodeString* |
| 542 DateFormatSymbols::getMonths(int32_t &count) const |
| 543 { |
| 544 count = fMonthsCount; |
| 545 return fMonths; |
| 546 } |
| 547 |
| 548 const UnicodeString* |
| 549 DateFormatSymbols::getShortMonths(int32_t &count) const |
| 550 { |
| 551 count = fShortMonthsCount; |
| 552 return fShortMonths; |
| 553 } |
| 554 |
| 555 const UnicodeString* |
| 556 DateFormatSymbols::getMonths(int32_t &count, DtContextType context, DtWidthType
width ) const |
| 557 { |
| 558 UnicodeString *returnValue = NULL; |
| 559 |
| 560 switch (context) { |
| 561 case FORMAT : |
| 562 switch(width) { |
| 563 case WIDE : |
| 564 count = fMonthsCount; |
| 565 returnValue = fMonths; |
| 566 break; |
| 567 case ABBREVIATED : |
| 568 count = fShortMonthsCount; |
| 569 returnValue = fShortMonths; |
| 570 break; |
| 571 case NARROW : |
| 572 count = fNarrowMonthsCount; |
| 573 returnValue = fNarrowMonths; |
| 574 break; |
| 575 case DT_WIDTH_COUNT : |
| 576 break; |
| 577 } |
| 578 break; |
| 579 case STANDALONE : |
| 580 switch(width) { |
| 581 case WIDE : |
| 582 count = fStandaloneMonthsCount; |
| 583 returnValue = fStandaloneMonths; |
| 584 break; |
| 585 case ABBREVIATED : |
| 586 count = fStandaloneShortMonthsCount; |
| 587 returnValue = fStandaloneShortMonths; |
| 588 break; |
| 589 case NARROW : |
| 590 count = fStandaloneNarrowMonthsCount; |
| 591 returnValue = fStandaloneNarrowMonths; |
| 592 break; |
| 593 case DT_WIDTH_COUNT : |
| 594 break; |
| 595 } |
| 596 break; |
| 597 case DT_CONTEXT_COUNT : |
| 598 break; |
| 599 } |
| 600 return returnValue; |
| 601 } |
| 602 |
| 603 const UnicodeString* |
| 604 DateFormatSymbols::getWeekdays(int32_t &count) const |
| 605 { |
| 606 count = fWeekdaysCount; |
| 607 return fWeekdays; |
| 608 } |
| 609 |
| 610 const UnicodeString* |
| 611 DateFormatSymbols::getShortWeekdays(int32_t &count) const |
| 612 { |
| 613 count = fShortWeekdaysCount; |
| 614 return fShortWeekdays; |
| 615 } |
| 616 |
| 617 const UnicodeString* |
| 618 DateFormatSymbols::getWeekdays(int32_t &count, DtContextType context, DtWidthTyp
e width) const |
| 619 { |
| 620 UnicodeString *returnValue = NULL; |
| 621 switch (context) { |
| 622 case FORMAT : |
| 623 switch(width) { |
| 624 case WIDE : |
| 625 count = fWeekdaysCount; |
| 626 returnValue = fWeekdays; |
| 627 break; |
| 628 case ABBREVIATED : |
| 629 count = fShortWeekdaysCount; |
| 630 returnValue = fShortWeekdays; |
| 631 break; |
| 632 case NARROW : |
| 633 count = fNarrowWeekdaysCount; |
| 634 returnValue = fNarrowWeekdays; |
| 635 break; |
| 636 case DT_WIDTH_COUNT : |
| 637 break; |
| 638 } |
| 639 break; |
| 640 case STANDALONE : |
| 641 switch(width) { |
| 642 case WIDE : |
| 643 count = fStandaloneWeekdaysCount; |
| 644 returnValue = fStandaloneWeekdays; |
| 645 break; |
| 646 case ABBREVIATED : |
| 647 count = fStandaloneShortWeekdaysCount; |
| 648 returnValue = fStandaloneShortWeekdays; |
| 649 break; |
| 650 case NARROW : |
| 651 count = fStandaloneNarrowWeekdaysCount; |
| 652 returnValue = fStandaloneNarrowWeekdays; |
| 653 break; |
| 654 case DT_WIDTH_COUNT : |
| 655 break; |
| 656 } |
| 657 break; |
| 658 case DT_CONTEXT_COUNT : |
| 659 break; |
| 660 } |
| 661 return returnValue; |
| 662 } |
| 663 |
| 664 const UnicodeString* |
| 665 DateFormatSymbols::getQuarters(int32_t &count, DtContextType context, DtWidthTyp
e width ) const |
| 666 { |
| 667 UnicodeString *returnValue = NULL; |
| 668 |
| 669 switch (context) { |
| 670 case FORMAT : |
| 671 switch(width) { |
| 672 case WIDE : |
| 673 count = fQuartersCount; |
| 674 returnValue = fQuarters; |
| 675 break; |
| 676 case ABBREVIATED : |
| 677 count = fShortQuartersCount; |
| 678 returnValue = fShortQuarters; |
| 679 break; |
| 680 case NARROW : |
| 681 count = 0; |
| 682 returnValue = NULL; |
| 683 break; |
| 684 case DT_WIDTH_COUNT : |
| 685 break; |
| 686 } |
| 687 break; |
| 688 case STANDALONE : |
| 689 switch(width) { |
| 690 case WIDE : |
| 691 count = fStandaloneQuartersCount; |
| 692 returnValue = fStandaloneQuarters; |
| 693 break; |
| 694 case ABBREVIATED : |
| 695 count = fStandaloneShortQuartersCount; |
| 696 returnValue = fStandaloneShortQuarters; |
| 697 break; |
| 698 case NARROW : |
| 699 count = 0; |
| 700 returnValue = NULL; |
| 701 break; |
| 702 case DT_WIDTH_COUNT : |
| 703 break; |
| 704 } |
| 705 break; |
| 706 case DT_CONTEXT_COUNT : |
| 707 break; |
| 708 } |
| 709 return returnValue; |
| 710 } |
| 711 |
| 712 const UnicodeString* |
| 713 DateFormatSymbols::getAmPmStrings(int32_t &count) const |
| 714 { |
| 715 count = fAmPmsCount; |
| 716 return fAmPms; |
| 717 } |
| 718 |
| 719 //------------------------------------------------------ |
| 720 |
| 721 void |
| 722 DateFormatSymbols::setEras(const UnicodeString* erasArray, int32_t count) |
| 723 { |
| 724 // delete the old list if we own it |
| 725 if (fEras) |
| 726 delete[] fEras; |
| 727 |
| 728 // we always own the new list, which we create here (we duplicate rather |
| 729 // than adopting the list passed in) |
| 730 fEras = newUnicodeStringArray(count); |
| 731 uprv_arrayCopy(erasArray,fEras, count); |
| 732 fErasCount = count; |
| 733 } |
| 734 |
| 735 void |
| 736 DateFormatSymbols::setEraNames(const UnicodeString* eraNamesArray, int32_t count
) |
| 737 { |
| 738 // delete the old list if we own it |
| 739 if (fEraNames) |
| 740 delete[] fEraNames; |
| 741 |
| 742 // we always own the new list, which we create here (we duplicate rather |
| 743 // than adopting the list passed in) |
| 744 fEraNames = newUnicodeStringArray(count); |
| 745 uprv_arrayCopy(eraNamesArray,fEraNames, count); |
| 746 fEraNamesCount = count; |
| 747 } |
| 748 |
| 749 void |
| 750 DateFormatSymbols::setNarrowEras(const UnicodeString* narrowErasArray, int32_t c
ount) |
| 751 { |
| 752 // delete the old list if we own it |
| 753 if (fNarrowEras) |
| 754 delete[] fNarrowEras; |
| 755 |
| 756 // we always own the new list, which we create here (we duplicate rather |
| 757 // than adopting the list passed in) |
| 758 fNarrowEras = newUnicodeStringArray(count); |
| 759 uprv_arrayCopy(narrowErasArray,fNarrowEras, count); |
| 760 fNarrowErasCount = count; |
| 761 } |
| 762 |
| 763 void |
| 764 DateFormatSymbols::setMonths(const UnicodeString* monthsArray, int32_t count) |
| 765 { |
| 766 // delete the old list if we own it |
| 767 if (fMonths) |
| 768 delete[] fMonths; |
| 769 |
| 770 // we always own the new list, which we create here (we duplicate rather |
| 771 // than adopting the list passed in) |
| 772 fMonths = newUnicodeStringArray(count); |
| 773 uprv_arrayCopy( monthsArray,fMonths,count); |
| 774 fMonthsCount = count; |
| 775 } |
| 776 |
| 777 void |
| 778 DateFormatSymbols::setShortMonths(const UnicodeString* shortMonthsArray, int32_t
count) |
| 779 { |
| 780 // delete the old list if we own it |
| 781 if (fShortMonths) |
| 782 delete[] fShortMonths; |
| 783 |
| 784 // we always own the new list, which we create here (we duplicate rather |
| 785 // than adopting the list passed in) |
| 786 fShortMonths = newUnicodeStringArray(count); |
| 787 uprv_arrayCopy(shortMonthsArray,fShortMonths, count); |
| 788 fShortMonthsCount = count; |
| 789 } |
| 790 |
| 791 void |
| 792 DateFormatSymbols::setMonths(const UnicodeString* monthsArray, int32_t count, Dt
ContextType context, DtWidthType width) |
| 793 { |
| 794 // delete the old list if we own it |
| 795 // we always own the new list, which we create here (we duplicate rather |
| 796 // than adopting the list passed in) |
| 797 |
| 798 switch (context) { |
| 799 case FORMAT : |
| 800 switch (width) { |
| 801 case WIDE : |
| 802 if (fMonths) |
| 803 delete[] fMonths; |
| 804 fMonths = newUnicodeStringArray(count); |
| 805 uprv_arrayCopy( monthsArray,fMonths,count); |
| 806 fMonthsCount = count; |
| 807 break; |
| 808 case ABBREVIATED : |
| 809 if (fShortMonths) |
| 810 delete[] fShortMonths; |
| 811 fShortMonths = newUnicodeStringArray(count); |
| 812 uprv_arrayCopy( monthsArray,fShortMonths,count); |
| 813 fShortMonthsCount = count; |
| 814 break; |
| 815 case NARROW : |
| 816 if (fNarrowMonths) |
| 817 delete[] fNarrowMonths; |
| 818 fNarrowMonths = newUnicodeStringArray(count); |
| 819 uprv_arrayCopy( monthsArray,fNarrowMonths,count); |
| 820 fNarrowMonthsCount = count; |
| 821 break; |
| 822 case DT_WIDTH_COUNT : |
| 823 break; |
| 824 } |
| 825 break; |
| 826 case STANDALONE : |
| 827 switch (width) { |
| 828 case WIDE : |
| 829 if (fStandaloneMonths) |
| 830 delete[] fStandaloneMonths; |
| 831 fStandaloneMonths = newUnicodeStringArray(count); |
| 832 uprv_arrayCopy( monthsArray,fStandaloneMonths,count); |
| 833 fStandaloneMonthsCount = count; |
| 834 break; |
| 835 case ABBREVIATED : |
| 836 if (fStandaloneShortMonths) |
| 837 delete[] fStandaloneShortMonths; |
| 838 fStandaloneShortMonths = newUnicodeStringArray(count); |
| 839 uprv_arrayCopy( monthsArray,fStandaloneShortMonths,count); |
| 840 fStandaloneShortMonthsCount = count; |
| 841 break; |
| 842 case NARROW : |
| 843 if (fStandaloneNarrowMonths) |
| 844 delete[] fStandaloneNarrowMonths; |
| 845 fStandaloneNarrowMonths = newUnicodeStringArray(count); |
| 846 uprv_arrayCopy( monthsArray,fStandaloneNarrowMonths,count); |
| 847 fStandaloneNarrowMonthsCount = count; |
| 848 break; |
| 849 case DT_WIDTH_COUNT : |
| 850 break; |
| 851 } |
| 852 break; |
| 853 case DT_CONTEXT_COUNT : |
| 854 break; |
| 855 } |
| 856 } |
| 857 |
| 858 void DateFormatSymbols::setWeekdays(const UnicodeString* weekdaysArray, int32_t
count) |
| 859 { |
| 860 // delete the old list if we own it |
| 861 if (fWeekdays) |
| 862 delete[] fWeekdays; |
| 863 |
| 864 // we always own the new list, which we create here (we duplicate rather |
| 865 // than adopting the list passed in) |
| 866 fWeekdays = newUnicodeStringArray(count); |
| 867 uprv_arrayCopy(weekdaysArray,fWeekdays,count); |
| 868 fWeekdaysCount = count; |
| 869 } |
| 870 |
| 871 void |
| 872 DateFormatSymbols::setShortWeekdays(const UnicodeString* shortWeekdaysArray, int
32_t count) |
| 873 { |
| 874 // delete the old list if we own it |
| 875 if (fShortWeekdays) |
| 876 delete[] fShortWeekdays; |
| 877 |
| 878 // we always own the new list, which we create here (we duplicate rather |
| 879 // than adopting the list passed in) |
| 880 fShortWeekdays = newUnicodeStringArray(count); |
| 881 uprv_arrayCopy(shortWeekdaysArray, fShortWeekdays, count); |
| 882 fShortWeekdaysCount = count; |
| 883 } |
| 884 |
| 885 void |
| 886 DateFormatSymbols::setWeekdays(const UnicodeString* weekdaysArray, int32_t count
, DtContextType context, DtWidthType width) |
| 887 { |
| 888 // delete the old list if we own it |
| 889 // we always own the new list, which we create here (we duplicate rather |
| 890 // than adopting the list passed in) |
| 891 |
| 892 switch (context) { |
| 893 case FORMAT : |
| 894 switch (width) { |
| 895 case WIDE : |
| 896 if (fWeekdays) |
| 897 delete[] fWeekdays; |
| 898 fWeekdays = newUnicodeStringArray(count); |
| 899 uprv_arrayCopy(weekdaysArray, fWeekdays, count); |
| 900 fWeekdaysCount = count; |
| 901 break; |
| 902 case ABBREVIATED : |
| 903 if (fShortWeekdays) |
| 904 delete[] fShortWeekdays; |
| 905 fShortWeekdays = newUnicodeStringArray(count); |
| 906 uprv_arrayCopy(weekdaysArray, fShortWeekdays, count); |
| 907 fShortWeekdaysCount = count; |
| 908 break; |
| 909 case NARROW : |
| 910 if (fNarrowWeekdays) |
| 911 delete[] fNarrowWeekdays; |
| 912 fNarrowWeekdays = newUnicodeStringArray(count); |
| 913 uprv_arrayCopy(weekdaysArray, fNarrowWeekdays, count); |
| 914 fNarrowWeekdaysCount = count; |
| 915 break; |
| 916 case DT_WIDTH_COUNT : |
| 917 break; |
| 918 } |
| 919 break; |
| 920 case STANDALONE : |
| 921 switch (width) { |
| 922 case WIDE : |
| 923 if (fStandaloneWeekdays) |
| 924 delete[] fStandaloneWeekdays; |
| 925 fStandaloneWeekdays = newUnicodeStringArray(count); |
| 926 uprv_arrayCopy(weekdaysArray, fStandaloneWeekdays, count); |
| 927 fStandaloneWeekdaysCount = count; |
| 928 break; |
| 929 case ABBREVIATED : |
| 930 if (fStandaloneShortWeekdays) |
| 931 delete[] fStandaloneShortWeekdays; |
| 932 fStandaloneShortWeekdays = newUnicodeStringArray(count); |
| 933 uprv_arrayCopy(weekdaysArray, fStandaloneShortWeekdays, count); |
| 934 fStandaloneShortWeekdaysCount = count; |
| 935 break; |
| 936 case NARROW : |
| 937 if (fStandaloneNarrowWeekdays) |
| 938 delete[] fStandaloneNarrowWeekdays; |
| 939 fStandaloneNarrowWeekdays = newUnicodeStringArray(count); |
| 940 uprv_arrayCopy(weekdaysArray, fStandaloneNarrowWeekdays, count); |
| 941 fStandaloneNarrowWeekdaysCount = count; |
| 942 break; |
| 943 case DT_WIDTH_COUNT : |
| 944 break; |
| 945 } |
| 946 break; |
| 947 case DT_CONTEXT_COUNT : |
| 948 break; |
| 949 } |
| 950 } |
| 951 |
| 952 void |
| 953 DateFormatSymbols::setQuarters(const UnicodeString* quartersArray, int32_t count
, DtContextType context, DtWidthType width) |
| 954 { |
| 955 // delete the old list if we own it |
| 956 // we always own the new list, which we create here (we duplicate rather |
| 957 // than adopting the list passed in) |
| 958 |
| 959 switch (context) { |
| 960 case FORMAT : |
| 961 switch (width) { |
| 962 case WIDE : |
| 963 if (fQuarters) |
| 964 delete[] fQuarters; |
| 965 fQuarters = newUnicodeStringArray(count); |
| 966 uprv_arrayCopy( quartersArray,fQuarters,count); |
| 967 fQuartersCount = count; |
| 968 break; |
| 969 case ABBREVIATED : |
| 970 if (fShortQuarters) |
| 971 delete[] fShortQuarters; |
| 972 fShortQuarters = newUnicodeStringArray(count); |
| 973 uprv_arrayCopy( quartersArray,fShortQuarters,count); |
| 974 fShortQuartersCount = count; |
| 975 break; |
| 976 case NARROW : |
| 977 /* |
| 978 if (fNarrowQuarters) |
| 979 delete[] fNarrowQuarters; |
| 980 fNarrowQuarters = newUnicodeStringArray(count); |
| 981 uprv_arrayCopy( quartersArray,fNarrowQuarters,count); |
| 982 fNarrowQuartersCount = count; |
| 983 */ |
| 984 break; |
| 985 case DT_WIDTH_COUNT : |
| 986 break; |
| 987 } |
| 988 break; |
| 989 case STANDALONE : |
| 990 switch (width) { |
| 991 case WIDE : |
| 992 if (fStandaloneQuarters) |
| 993 delete[] fStandaloneQuarters; |
| 994 fStandaloneQuarters = newUnicodeStringArray(count); |
| 995 uprv_arrayCopy( quartersArray,fStandaloneQuarters,count); |
| 996 fStandaloneQuartersCount = count; |
| 997 break; |
| 998 case ABBREVIATED : |
| 999 if (fStandaloneShortQuarters) |
| 1000 delete[] fStandaloneShortQuarters; |
| 1001 fStandaloneShortQuarters = newUnicodeStringArray(count); |
| 1002 uprv_arrayCopy( quartersArray,fStandaloneShortQuarters,count); |
| 1003 fStandaloneShortQuartersCount = count; |
| 1004 break; |
| 1005 case NARROW : |
| 1006 /* |
| 1007 if (fStandaloneNarrowQuarters) |
| 1008 delete[] fStandaloneNarrowQuarters; |
| 1009 fStandaloneNarrowQuarters = newUnicodeStringArray(count); |
| 1010 uprv_arrayCopy( quartersArray,fStandaloneNarrowQuarters,count); |
| 1011 fStandaloneNarrowQuartersCount = count; |
| 1012 */ |
| 1013 break; |
| 1014 case DT_WIDTH_COUNT : |
| 1015 break; |
| 1016 } |
| 1017 break; |
| 1018 case DT_CONTEXT_COUNT : |
| 1019 break; |
| 1020 } |
| 1021 } |
| 1022 |
| 1023 void |
| 1024 DateFormatSymbols::setAmPmStrings(const UnicodeString* amPmsArray, int32_t count
) |
| 1025 { |
| 1026 // delete the old list if we own it |
| 1027 if (fAmPms) delete[] fAmPms; |
| 1028 |
| 1029 // we always own the new list, which we create here (we duplicate rather |
| 1030 // than adopting the list passed in) |
| 1031 fAmPms = newUnicodeStringArray(count); |
| 1032 uprv_arrayCopy(amPmsArray,fAmPms,count); |
| 1033 fAmPmsCount = count; |
| 1034 } |
| 1035 |
| 1036 //------------------------------------------------------ |
| 1037 const ZoneStringFormat* |
| 1038 DateFormatSymbols::getZoneStringFormat(void) const { |
| 1039 umtx_lock(&LOCK); |
| 1040 if (fZoneStringFormat == NULL) { |
| 1041 ((DateFormatSymbols*)this)->initZoneStringFormat(); |
| 1042 } |
| 1043 umtx_unlock(&LOCK); |
| 1044 return fZoneStringFormat; |
| 1045 } |
| 1046 |
| 1047 void |
| 1048 DateFormatSymbols::initZoneStringFormat(void) { |
| 1049 if (fZoneStringFormat == NULL) { |
| 1050 UErrorCode status = U_ZERO_ERROR; |
| 1051 if (fZoneStrings) { |
| 1052 // Create an istance of ZoneStringFormat by the custom zone strings
array |
| 1053 fZSFLocal = new ZoneStringFormat(fZoneStrings, fZoneStringsRowCount, |
| 1054 fZoneStringsColCount, status); |
| 1055 if (U_FAILURE(status)) { |
| 1056 delete fZSFLocal; |
| 1057 } else { |
| 1058 fZoneStringFormat = (const ZoneStringFormat*)fZSFLocal; |
| 1059 } |
| 1060 } else { |
| 1061 fZSFCachePtr = ZoneStringFormat::getZoneStringFormat(fZSFLocale, sta
tus); |
| 1062 if (U_FAILURE(status)) { |
| 1063 delete fZSFCachePtr; |
| 1064 } else { |
| 1065 fZoneStringFormat = fZSFCachePtr->get(); |
| 1066 } |
| 1067 } |
| 1068 } |
| 1069 } |
| 1070 |
| 1071 const UnicodeString** |
| 1072 DateFormatSymbols::getZoneStrings(int32_t& rowCount, int32_t& columnCount) const |
| 1073 { |
| 1074 const UnicodeString **result = NULL; |
| 1075 |
| 1076 umtx_lock(&LOCK); |
| 1077 if (fZoneStrings == NULL) { |
| 1078 if (fLocaleZoneStrings == NULL) { |
| 1079 ((DateFormatSymbols*)this)->initZoneStringsArray(); |
| 1080 } |
| 1081 result = (const UnicodeString**)fLocaleZoneStrings; |
| 1082 } else { |
| 1083 result = (const UnicodeString**)fZoneStrings; |
| 1084 } |
| 1085 rowCount = fZoneStringsRowCount; |
| 1086 columnCount = fZoneStringsColCount; |
| 1087 umtx_unlock(&LOCK); |
| 1088 |
| 1089 return result; |
| 1090 } |
| 1091 |
| 1092 void |
| 1093 DateFormatSymbols::initZoneStringsArray(void) { |
| 1094 if (fZoneStrings == NULL && fLocaleZoneStrings == NULL) { |
| 1095 if (fZoneStringFormat == NULL) { |
| 1096 initZoneStringFormat(); |
| 1097 } |
| 1098 if (fZoneStringFormat) { |
| 1099 UErrorCode status = U_ZERO_ERROR; |
| 1100 fLocaleZoneStrings = fZoneStringFormat->createZoneStringsArray(uprv_
getUTCtime() /* use current time */, |
| 1101 fZoneStringsRowCount, fZoneStringsColCount, status); |
| 1102 } |
| 1103 } |
| 1104 } |
| 1105 |
| 1106 void |
| 1107 DateFormatSymbols::setZoneStrings(const UnicodeString* const *strings, int32_t r
owCount, int32_t columnCount) |
| 1108 { |
| 1109 // since deleting a 2-d array is a pain in the butt, we offload that task to |
| 1110 // a separate function |
| 1111 disposeZoneStrings(); |
| 1112 // we always own the new list, which we create here (we duplicate rather |
| 1113 // than adopting the list passed in) |
| 1114 fZoneStringsRowCount = rowCount; |
| 1115 fZoneStringsColCount = columnCount; |
| 1116 createZoneStrings((const UnicodeString**)strings); |
| 1117 } |
| 1118 |
| 1119 //------------------------------------------------------ |
| 1120 |
| 1121 const UChar * U_EXPORT2 |
| 1122 DateFormatSymbols::getPatternUChars(void) |
| 1123 { |
| 1124 return gPatternChars; |
| 1125 } |
| 1126 |
| 1127 //------------------------------------------------------ |
| 1128 |
| 1129 UnicodeString& |
| 1130 DateFormatSymbols::getLocalPatternChars(UnicodeString& result) const |
| 1131 { |
| 1132 // fastCopyFrom() - see assignArray comments |
| 1133 return result.fastCopyFrom(fLocalPatternChars); |
| 1134 } |
| 1135 |
| 1136 //------------------------------------------------------ |
| 1137 |
| 1138 void |
| 1139 DateFormatSymbols::setLocalPatternChars(const UnicodeString& newLocalPatternChar
s) |
| 1140 { |
| 1141 fLocalPatternChars = newLocalPatternChars; |
| 1142 } |
| 1143 |
| 1144 //------------------------------------------------------ |
| 1145 |
| 1146 static void |
| 1147 initField(UnicodeString **field, int32_t& length, const UResourceBundle *data, U
ErrorCode &status) { |
| 1148 if (U_SUCCESS(status)) { |
| 1149 int32_t strLen = 0; |
| 1150 length = ures_getSize(data); |
| 1151 *field = newUnicodeStringArray(length); |
| 1152 if (*field) { |
| 1153 for(int32_t i = 0; i<length; i++) { |
| 1154 const UChar *resStr = ures_getStringByIndex(data, i, &strLen, &s
tatus); |
| 1155 // setTo() - see assignArray comments |
| 1156 (*(field)+i)->setTo(TRUE, resStr, strLen); |
| 1157 } |
| 1158 } |
| 1159 else { |
| 1160 length = 0; |
| 1161 status = U_MEMORY_ALLOCATION_ERROR; |
| 1162 } |
| 1163 } |
| 1164 } |
| 1165 |
| 1166 static void |
| 1167 initField(UnicodeString **field, int32_t& length, const UChar *data, LastResortS
ize numStr, LastResortSize strLen, UErrorCode &status) { |
| 1168 if (U_SUCCESS(status)) { |
| 1169 length = numStr; |
| 1170 *field = newUnicodeStringArray((size_t)numStr); |
| 1171 if (*field) { |
| 1172 for(int32_t i = 0; i<length; i++) { |
| 1173 // readonly aliases - all "data" strings are constant |
| 1174 // -1 as length for variable-length strings (gLastResortDayNames
[0] is empty) |
| 1175 (*(field)+i)->setTo(TRUE, data+(i*((int32_t)strLen)), -1); |
| 1176 } |
| 1177 } |
| 1178 else { |
| 1179 length = 0; |
| 1180 status = U_MEMORY_ALLOCATION_ERROR; |
| 1181 } |
| 1182 } |
| 1183 } |
| 1184 |
| 1185 void |
| 1186 DateFormatSymbols::initializeData(const Locale& locale, const char *type, UError
Code& status, UBool useLastResortData) |
| 1187 { |
| 1188 int32_t i; |
| 1189 int32_t len = 0; |
| 1190 const UChar *resStr; |
| 1191 /* In case something goes wrong, initialize all of the data to NULL. */ |
| 1192 fEras = NULL; |
| 1193 fErasCount = 0; |
| 1194 fEraNames = NULL; |
| 1195 fEraNamesCount = 0; |
| 1196 fNarrowEras = NULL; |
| 1197 fNarrowErasCount = 0; |
| 1198 fMonths = NULL; |
| 1199 fMonthsCount=0; |
| 1200 fShortMonths = NULL; |
| 1201 fShortMonthsCount=0; |
| 1202 fNarrowMonths = NULL; |
| 1203 fNarrowMonthsCount=0; |
| 1204 fStandaloneMonths = NULL; |
| 1205 fStandaloneMonthsCount=0; |
| 1206 fStandaloneShortMonths = NULL; |
| 1207 fStandaloneShortMonthsCount=0; |
| 1208 fStandaloneNarrowMonths = NULL; |
| 1209 fStandaloneNarrowMonthsCount=0; |
| 1210 fWeekdays = NULL; |
| 1211 fWeekdaysCount=0; |
| 1212 fShortWeekdays = NULL; |
| 1213 fShortWeekdaysCount=0; |
| 1214 fNarrowWeekdays = NULL; |
| 1215 fNarrowWeekdaysCount=0; |
| 1216 fStandaloneWeekdays = NULL; |
| 1217 fStandaloneWeekdaysCount=0; |
| 1218 fStandaloneShortWeekdays = NULL; |
| 1219 fStandaloneShortWeekdaysCount=0; |
| 1220 fStandaloneNarrowWeekdays = NULL; |
| 1221 fStandaloneNarrowWeekdaysCount=0; |
| 1222 fAmPms = NULL; |
| 1223 fAmPmsCount=0; |
| 1224 fQuarters = NULL; |
| 1225 fQuartersCount = 0; |
| 1226 fShortQuarters = NULL; |
| 1227 fShortQuartersCount = 0; |
| 1228 fStandaloneQuarters = NULL; |
| 1229 fStandaloneQuartersCount = 0; |
| 1230 fStandaloneShortQuarters = NULL; |
| 1231 fStandaloneShortQuartersCount = 0; |
| 1232 fGmtHourFormats = NULL; |
| 1233 fGmtHourFormatsCount = 0; |
| 1234 fZoneStringsRowCount = 0; |
| 1235 fZoneStringsColCount = 0; |
| 1236 fZoneStrings = NULL; |
| 1237 fLocaleZoneStrings = NULL; |
| 1238 |
| 1239 fZoneStringFormat = NULL; |
| 1240 fZSFLocal = NULL; |
| 1241 fZSFCachePtr = NULL; |
| 1242 |
| 1243 // We need to preserve the requested locale for |
| 1244 // lazy ZoneStringFormat instantiation. ZoneStringFormat |
| 1245 // is region sensitive, thus, bundle locale bundle's locale |
| 1246 // is not sufficient. |
| 1247 fZSFLocale = locale; |
| 1248 |
| 1249 if (U_FAILURE(status)) return; |
| 1250 |
| 1251 /** |
| 1252 * Retrieve the string arrays we need from the resource bundle file. |
| 1253 * We cast away const here, but that's okay; we won't delete any of |
| 1254 * these. |
| 1255 */ |
| 1256 CalendarData calData(locale, type, status); |
| 1257 |
| 1258 /** |
| 1259 * Use the localeBundle for getting zone GMT formatting patterns |
| 1260 */ |
| 1261 UResourceBundle *zoneBundle = ures_open(U_ICUDATA_ZONE, locale.getName(), &s
tatus); |
| 1262 UResourceBundle *zoneStringsArray = ures_getByKeyWithFallback(zoneBundle, gZ
oneStringsTag, NULL, &status); |
| 1263 |
| 1264 // load the first data item |
| 1265 UResourceBundle *erasMain = calData.getByKey(gErasTag, status); |
| 1266 UResourceBundle *eras = ures_getByKeyWithFallback(erasMain, gNamesAbbrTag, N
ULL, &status); |
| 1267 UErrorCode oldStatus = status; |
| 1268 UResourceBundle *eraNames = ures_getByKeyWithFallback(erasMain, gNamesWideTa
g, NULL, &status); |
| 1269 if ( status == U_MISSING_RESOURCE_ERROR ) { // Workaround because eras/wide
was omitted from CLDR 1.3 |
| 1270 status = oldStatus; |
| 1271 eraNames = ures_getByKeyWithFallback(erasMain, gNamesAbbrTag, NULL, &stat
us); |
| 1272 } |
| 1273 // current ICU4J falls back to abbreviated if narrow eras are missing, s
o we will too |
| 1274 oldStatus = status; |
| 1275 UResourceBundle *narrowEras = ures_getByKeyWithFallback(erasMain, gNamesNarr
owTag, NULL, &status); |
| 1276 if ( status == U_MISSING_RESOURCE_ERROR ) { |
| 1277 status = oldStatus; |
| 1278 narrowEras = ures_getByKeyWithFallback(erasMain, gNamesAbbrTag, NULL, &st
atus); |
| 1279 } |
| 1280 |
| 1281 UResourceBundle *lsweekdaysData = NULL; // Data closed by calData |
| 1282 UResourceBundle *weekdaysData = NULL; // Data closed by calData |
| 1283 UResourceBundle *narrowWeekdaysData = NULL; // Data closed by calData |
| 1284 UResourceBundle *standaloneWeekdaysData = NULL; // Data closed by calData |
| 1285 UResourceBundle *standaloneShortWeekdaysData = NULL; // Data closed by calDa
ta |
| 1286 UResourceBundle *standaloneNarrowWeekdaysData = NULL; // Data closed by calD
ata |
| 1287 |
| 1288 U_LOCALE_BASED(locBased, *this); |
| 1289 if (U_FAILURE(status)) |
| 1290 { |
| 1291 if (useLastResortData) |
| 1292 { |
| 1293 // Handle the case in which there is no resource data present. |
| 1294 // We don't have to generate usable patterns in this situation; |
| 1295 // we just need to produce something that will be semi-intelligible |
| 1296 // in most locales. |
| 1297 |
| 1298 status = U_USING_FALLBACK_WARNING; |
| 1299 |
| 1300 initField(&fEras, fErasCount, (const UChar *)gLastResortEras, kEraNu
m, kEraLen, status); |
| 1301 initField(&fEraNames, fEraNamesCount, (const UChar *)gLastResortEras
, kEraNum, kEraLen, status); |
| 1302 initField(&fNarrowEras, fNarrowErasCount, (const UChar *)gLastResort
Eras, kEraNum, kEraLen, status); |
| 1303 initField(&fMonths, fMonthsCount, (const UChar *)gLastResortMonthNam
es, kMonthNum, kMonthLen, status); |
| 1304 initField(&fShortMonths, fShortMonthsCount, (const UChar *)gLastReso
rtMonthNames, kMonthNum, kMonthLen, status); |
| 1305 initField(&fNarrowMonths, fNarrowMonthsCount, (const UChar *)gLastRe
sortMonthNames, kMonthNum, kMonthLen, status); |
| 1306 initField(&fStandaloneMonths, fStandaloneMonthsCount, (const UChar *
)gLastResortMonthNames, kMonthNum, kMonthLen, status); |
| 1307 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, (con
st UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); |
| 1308 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, (c
onst UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); |
| 1309 initField(&fWeekdays, fWeekdaysCount, (const UChar *)gLastResortDayN
ames, kDayNum, kDayLen, status); |
| 1310 initField(&fShortWeekdays, fShortWeekdaysCount, (const UChar *)gLast
ResortDayNames, kDayNum, kDayLen, status); |
| 1311 initField(&fNarrowWeekdays, fNarrowWeekdaysCount, (const UChar *)gLa
stResortDayNames, kDayNum, kDayLen, status); |
| 1312 initField(&fStandaloneWeekdays, fStandaloneWeekdaysCount, (const UCh
ar *)gLastResortDayNames, kDayNum, kDayLen, status); |
| 1313 initField(&fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount,
(const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); |
| 1314 initField(&fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount
, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); |
| 1315 initField(&fAmPms, fAmPmsCount, (const UChar *)gLastResortAmPmMarker
s, kAmPmNum, kAmPmLen, status); |
| 1316 initField(&fQuarters, fQuartersCount, (const UChar *)gLastResortQuar
ters, kQuarterNum, kQuarterLen, status); |
| 1317 initField(&fShortQuarters, fShortQuartersCount, (const UChar *)gLast
ResortQuarters, kQuarterNum, kQuarterLen, status); |
| 1318 initField(&fStandaloneQuarters, fStandaloneQuartersCount, (const UCh
ar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status); |
| 1319 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount,
(const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status); |
| 1320 initField(&fGmtHourFormats, fGmtHourFormatsCount, (const UChar *)gLa
stResortGmtHourFormats, kGmtHourNum, kGmtHourLen, status); |
| 1321 fGmtFormat.setTo(TRUE, gLastResortGmtFormat, -1); |
| 1322 fLocalPatternChars.setTo(TRUE, gPatternChars, PATTERN_CHARS_LEN); |
| 1323 } |
| 1324 goto cleanup; |
| 1325 } |
| 1326 |
| 1327 // if we make it to here, the resource data is cool, and we can get everythi
ng out |
| 1328 // of it that we need except for the time-zone and localized-pattern data, w
hich |
| 1329 // are stored in a separate file |
| 1330 locBased.setLocaleIDs(ures_getLocaleByType(eras, ULOC_VALID_LOCALE, &status)
, |
| 1331 ures_getLocaleByType(eras, ULOC_ACTUAL_LOCALE, &status
)); |
| 1332 |
| 1333 initField(&fEras, fErasCount, eras, status); |
| 1334 initField(&fEraNames, fEraNamesCount, eraNames, status); |
| 1335 initField(&fNarrowEras, fNarrowErasCount, narrowEras, status); |
| 1336 |
| 1337 initField(&fMonths, fMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesWi
deTag, status), status); |
| 1338 initField(&fShortMonths, fShortMonthsCount, calData.getByKey2(gMonthNamesTag
, gNamesAbbrTag, status), status); |
| 1339 |
| 1340 initField(&fNarrowMonths, fNarrowMonthsCount, calData.getByKey2(gMonthNamesT
ag, gNamesNarrowTag, status), status); |
| 1341 if(status == U_MISSING_RESOURCE_ERROR) { |
| 1342 status = U_ZERO_ERROR; |
| 1343 initField(&fNarrowMonths, fNarrowMonthsCount, calData.getByKey3(gMonthNa
mesTag, gNamesStandaloneTag, gNamesNarrowTag, status), status); |
| 1344 } |
| 1345 if ( status == U_MISSING_RESOURCE_ERROR ) { /* If format/narrow not availabl
e, use format/abbreviated */ |
| 1346 status = U_ZERO_ERROR; |
| 1347 initField(&fNarrowMonths, fNarrowMonthsCount, calData.getByKey2(gMonthNam
esTag, gNamesAbbrTag, status), status); |
| 1348 } |
| 1349 |
| 1350 initField(&fStandaloneMonths, fStandaloneMonthsCount, calData.getByKey3(gMon
thNamesTag, gNamesStandaloneTag, gNamesWideTag, status), status); |
| 1351 if ( status == U_MISSING_RESOURCE_ERROR ) { /* If standalone/wide not availa
ble, use format/wide */ |
| 1352 status = U_ZERO_ERROR; |
| 1353 initField(&fStandaloneMonths, fStandaloneMonthsCount, calData.getByKey2(g
MonthNamesTag, gNamesWideTag, status), status); |
| 1354 } |
| 1355 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, calData.getB
yKey3(gMonthNamesTag, gNamesStandaloneTag, gNamesAbbrTag, status), status); |
| 1356 if ( status == U_MISSING_RESOURCE_ERROR ) { /* If standalone/abbreviated not
available, use format/abbreviated */ |
| 1357 status = U_ZERO_ERROR; |
| 1358 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, calData.g
etByKey2(gMonthNamesTag, gNamesAbbrTag, status), status); |
| 1359 } |
| 1360 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calData.ge
tByKey3(gMonthNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status), status); |
| 1361 if ( status == U_MISSING_RESOURCE_ERROR ) { /* if standalone/narrow not avai
labe, try format/narrow */ |
| 1362 status = U_ZERO_ERROR; |
| 1363 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calData
.getByKey2(gMonthNamesTag, gNamesNarrowTag, status), status); |
| 1364 if ( status == U_MISSING_RESOURCE_ERROR ) { /* if still not there, use fo
rmat/abbreviated */ |
| 1365 status = U_ZERO_ERROR; |
| 1366 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calD
ata.getByKey2(gMonthNamesTag, gNamesAbbrTag, status), status); |
| 1367 } |
| 1368 } |
| 1369 initField(&fAmPms, fAmPmsCount, calData.getByKey(gAmPmMarkersTag, status), s
tatus); |
| 1370 |
| 1371 initField(&fQuarters, fQuartersCount, calData.getByKey2(gQuartersTag, gNames
WideTag, status), status); |
| 1372 initField(&fShortQuarters, fShortQuartersCount, calData.getByKey2(gQuartersT
ag, gNamesAbbrTag, status), status); |
| 1373 |
| 1374 initField(&fStandaloneQuarters, fStandaloneQuartersCount, calData.getByKey3(
gQuartersTag, gNamesStandaloneTag, gNamesWideTag, status), status); |
| 1375 if(status == U_MISSING_RESOURCE_ERROR) { |
| 1376 status = U_ZERO_ERROR; |
| 1377 initField(&fStandaloneQuarters, fStandaloneQuartersCount, calData.getByK
ey2(gQuartersTag, gNamesWideTag, status), status); |
| 1378 } |
| 1379 |
| 1380 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, calData.
getByKey3(gQuartersTag, gNamesStandaloneTag, gNamesAbbrTag, status), status); |
| 1381 if(status == U_MISSING_RESOURCE_ERROR) { |
| 1382 status = U_ZERO_ERROR; |
| 1383 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, calD
ata.getByKey2(gQuartersTag, gNamesAbbrTag, status), status); |
| 1384 } |
| 1385 |
| 1386 // GMT format patterns |
| 1387 resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gGmtFormatTag, &l
en, &status); |
| 1388 if (len > 0) { |
| 1389 fGmtFormat.setTo(TRUE, resStr, len); |
| 1390 } |
| 1391 |
| 1392 resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gHourFormatTag, &
len, &status); |
| 1393 if (len > 0) { |
| 1394 UChar *sep = u_strchr(resStr, (UChar)0x003B /* ';' */); |
| 1395 if (sep != NULL) { |
| 1396 fGmtHourFormats = newUnicodeStringArray(GMT_HOUR_COUNT); |
| 1397 if (fGmtHourFormats == NULL) { |
| 1398 status = U_MEMORY_ALLOCATION_ERROR; |
| 1399 } else { |
| 1400 fGmtHourFormatsCount = GMT_HOUR_COUNT; |
| 1401 fGmtHourFormats[GMT_NEGATIVE_HM].setTo(TRUE, sep + 1, -1); |
| 1402 fGmtHourFormats[GMT_POSITIVE_HM].setTo(FALSE, resStr, (int32_t)(
sep - resStr)); |
| 1403 |
| 1404 // CLDR 1.5 does not have GMT offset pattern including second fi
eld. |
| 1405 // For now, append "ss" to the end. |
| 1406 if (fGmtHourFormats[GMT_NEGATIVE_HM].indexOf((UChar)0x003A /* ':
' */) != -1) { |
| 1407 fGmtHourFormats[GMT_NEGATIVE_HMS] = fGmtHourFormats[GMT_NEGA
TIVE_HM] + UNICODE_STRING_SIMPLE(":ss"); |
| 1408 } else if (fGmtHourFormats[GMT_NEGATIVE_HM].indexOf((UChar)0x002
E /* '.' */) != -1) { |
| 1409 fGmtHourFormats[GMT_NEGATIVE_HMS] = fGmtHourFormats[GMT_NEGA
TIVE_HM] + UNICODE_STRING_SIMPLE(".ss"); |
| 1410 } else { |
| 1411 fGmtHourFormats[GMT_NEGATIVE_HMS] = fGmtHourFormats[GMT_NEGA
TIVE_HM] + UNICODE_STRING_SIMPLE("ss"); |
| 1412 } |
| 1413 if (fGmtHourFormats[GMT_POSITIVE_HM].indexOf((UChar)0x003A /* ':
' */) != -1) { |
| 1414 fGmtHourFormats[GMT_POSITIVE_HMS] = fGmtHourFormats[GMT_POSI
TIVE_HM] + UNICODE_STRING_SIMPLE(":ss"); |
| 1415 } else if (fGmtHourFormats[GMT_POSITIVE_HM].indexOf((UChar)0x002
E /* '.' */) != -1) { |
| 1416 fGmtHourFormats[GMT_POSITIVE_HMS] = fGmtHourFormats[GMT_POSI
TIVE_HM] + UNICODE_STRING_SIMPLE(".ss"); |
| 1417 } else { |
| 1418 fGmtHourFormats[GMT_POSITIVE_HMS] = fGmtHourFormats[GMT_POSI
TIVE_HM] + UNICODE_STRING_SIMPLE("ss"); |
| 1419 } |
| 1420 } |
| 1421 } |
| 1422 } |
| 1423 |
| 1424 // ICU 3.8 or later version no longer uses localized date-time pattern chara
cters by default (ticket#5597) |
| 1425 /* |
| 1426 // fastCopyFrom()/setTo() - see assignArray comments |
| 1427 resStr = ures_getStringByKey(fResourceBundle, gLocalPatternCharsTag, &len, &
status); |
| 1428 fLocalPatternChars.setTo(TRUE, resStr, len); |
| 1429 // If the locale data does not include new pattern chars, use the defaults |
| 1430 // TODO: Consider making this an error, since this may add conflicting chara
cters. |
| 1431 if (len < PATTERN_CHARS_LEN) { |
| 1432 fLocalPatternChars.append(UnicodeString(TRUE, &gPatternChars[len], PATTE
RN_CHARS_LEN-len)); |
| 1433 } |
| 1434 */ |
| 1435 fLocalPatternChars.setTo(TRUE, gPatternChars, PATTERN_CHARS_LEN); |
| 1436 |
| 1437 // {sfb} fixed to handle 1-based weekdays |
| 1438 weekdaysData = calData.getByKey2(gDayNamesTag, gNamesWideTag, status); |
| 1439 fWeekdaysCount = ures_getSize(weekdaysData); |
| 1440 fWeekdays = new UnicodeString[fWeekdaysCount+1]; |
| 1441 /* pin the blame on system. If we cannot get a chunk of memory .. the system
is dying!*/ |
| 1442 if (fWeekdays == NULL) { |
| 1443 status = U_MEMORY_ALLOCATION_ERROR; |
| 1444 goto cleanup; |
| 1445 } |
| 1446 // leave fWeekdays[0] empty |
| 1447 for(i = 0; i<fWeekdaysCount; i++) { |
| 1448 resStr = ures_getStringByIndex(weekdaysData, i, &len, &status); |
| 1449 // setTo() - see assignArray comments |
| 1450 fWeekdays[i+1].setTo(TRUE, resStr, len); |
| 1451 } |
| 1452 fWeekdaysCount++; |
| 1453 |
| 1454 lsweekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); |
| 1455 fShortWeekdaysCount = ures_getSize(lsweekdaysData); |
| 1456 fShortWeekdays = new UnicodeString[fShortWeekdaysCount+1]; |
| 1457 /* test for NULL */ |
| 1458 if (fShortWeekdays == 0) { |
| 1459 status = U_MEMORY_ALLOCATION_ERROR; |
| 1460 goto cleanup; |
| 1461 } |
| 1462 // leave fShortWeekdays[0] empty |
| 1463 for(i = 0; i<fShortWeekdaysCount; i++) { |
| 1464 resStr = ures_getStringByIndex(lsweekdaysData, i, &len, &status); |
| 1465 // setTo() - see assignArray comments |
| 1466 fShortWeekdays[i+1].setTo(TRUE, resStr, len); |
| 1467 } |
| 1468 fShortWeekdaysCount++; |
| 1469 |
| 1470 narrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesNarrowTag, status
); |
| 1471 if(status == U_MISSING_RESOURCE_ERROR) { |
| 1472 status = U_ZERO_ERROR; |
| 1473 narrowWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag
, gNamesNarrowTag, status); |
| 1474 } |
| 1475 if ( status == U_MISSING_RESOURCE_ERROR ) { |
| 1476 status = U_ZERO_ERROR; |
| 1477 narrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, statu
s); |
| 1478 } |
| 1479 fNarrowWeekdaysCount = ures_getSize(narrowWeekdaysData); |
| 1480 fNarrowWeekdays = new UnicodeString[fNarrowWeekdaysCount+1]; |
| 1481 /* test for NULL */ |
| 1482 if (fNarrowWeekdays == 0) { |
| 1483 status = U_MEMORY_ALLOCATION_ERROR; |
| 1484 goto cleanup; |
| 1485 } |
| 1486 // leave fNarrowWeekdays[0] empty |
| 1487 for(i = 0; i<fNarrowWeekdaysCount; i++) { |
| 1488 resStr = ures_getStringByIndex(narrowWeekdaysData, i, &len, &status); |
| 1489 // setTo() - see assignArray comments |
| 1490 fNarrowWeekdays[i+1].setTo(TRUE, resStr, len); |
| 1491 } |
| 1492 fNarrowWeekdaysCount++; |
| 1493 |
| 1494 standaloneWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag
, gNamesWideTag, status); |
| 1495 if ( status == U_MISSING_RESOURCE_ERROR ) { |
| 1496 status = U_ZERO_ERROR; |
| 1497 standaloneWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesWideTag, s
tatus); |
| 1498 } |
| 1499 fStandaloneWeekdaysCount = ures_getSize(standaloneWeekdaysData); |
| 1500 fStandaloneWeekdays = new UnicodeString[fStandaloneWeekdaysCount+1]; |
| 1501 /* test for NULL */ |
| 1502 if (fStandaloneWeekdays == 0) { |
| 1503 status = U_MEMORY_ALLOCATION_ERROR; |
| 1504 goto cleanup; |
| 1505 } |
| 1506 // leave fStandaloneWeekdays[0] empty |
| 1507 for(i = 0; i<fStandaloneWeekdaysCount; i++) { |
| 1508 resStr = ures_getStringByIndex(standaloneWeekdaysData, i, &len, &status)
; |
| 1509 // setTo() - see assignArray comments |
| 1510 fStandaloneWeekdays[i+1].setTo(TRUE, resStr, len); |
| 1511 } |
| 1512 fStandaloneWeekdaysCount++; |
| 1513 |
| 1514 standaloneShortWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandalo
neTag, gNamesAbbrTag, status); |
| 1515 if ( status == U_MISSING_RESOURCE_ERROR ) { |
| 1516 status = U_ZERO_ERROR; |
| 1517 standaloneShortWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrT
ag, status); |
| 1518 } |
| 1519 fStandaloneShortWeekdaysCount = ures_getSize(standaloneShortWeekdaysData); |
| 1520 fStandaloneShortWeekdays = new UnicodeString[fStandaloneShortWeekdaysCount+1
]; |
| 1521 /* test for NULL */ |
| 1522 if (fStandaloneShortWeekdays == 0) { |
| 1523 status = U_MEMORY_ALLOCATION_ERROR; |
| 1524 goto cleanup; |
| 1525 } |
| 1526 // leave fStandaloneShortWeekdays[0] empty |
| 1527 for(i = 0; i<fStandaloneShortWeekdaysCount; i++) { |
| 1528 resStr = ures_getStringByIndex(standaloneShortWeekdaysData, i, &len, &st
atus); |
| 1529 // setTo() - see assignArray comments |
| 1530 fStandaloneShortWeekdays[i+1].setTo(TRUE, resStr, len); |
| 1531 } |
| 1532 fStandaloneShortWeekdaysCount++; |
| 1533 |
| 1534 standaloneNarrowWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandal
oneTag, gNamesNarrowTag, status); |
| 1535 if ( status == U_MISSING_RESOURCE_ERROR ) { |
| 1536 status = U_ZERO_ERROR; |
| 1537 standaloneNarrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesNarr
owTag, status); |
| 1538 if ( status == U_MISSING_RESOURCE_ERROR ) { |
| 1539 status = U_ZERO_ERROR; |
| 1540 standaloneNarrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesA
bbrTag, status); |
| 1541 } |
| 1542 } |
| 1543 fStandaloneNarrowWeekdaysCount = ures_getSize(standaloneNarrowWeekdaysData); |
| 1544 fStandaloneNarrowWeekdays = new UnicodeString[fStandaloneNarrowWeekdaysCount
+1]; |
| 1545 /* test for NULL */ |
| 1546 if (fStandaloneNarrowWeekdays == 0) { |
| 1547 status = U_MEMORY_ALLOCATION_ERROR; |
| 1548 goto cleanup; |
| 1549 } |
| 1550 // leave fStandaloneNarrowWeekdays[0] empty |
| 1551 for(i = 0; i<fStandaloneNarrowWeekdaysCount; i++) { |
| 1552 resStr = ures_getStringByIndex(standaloneNarrowWeekdaysData, i, &len, &s
tatus); |
| 1553 // setTo() - see assignArray comments |
| 1554 fStandaloneNarrowWeekdays[i+1].setTo(TRUE, resStr, len); |
| 1555 } |
| 1556 fStandaloneNarrowWeekdaysCount++; |
| 1557 |
| 1558 cleanup: |
| 1559 ures_close(eras); |
| 1560 ures_close(eraNames); |
| 1561 ures_close(narrowEras); |
| 1562 ures_close(zoneStringsArray); |
| 1563 ures_close(zoneBundle); |
| 1564 } |
| 1565 |
| 1566 Locale |
| 1567 DateFormatSymbols::getLocale(ULocDataLocaleType type, UErrorCode& status) const
{ |
| 1568 U_LOCALE_BASED(locBased, *this); |
| 1569 return locBased.getLocale(type, status); |
| 1570 } |
| 1571 |
| 1572 U_NAMESPACE_END |
| 1573 |
| 1574 #endif /* #if !UCONFIG_NO_FORMATTING */ |
| 1575 |
| 1576 //eof |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 5516007:
Check in the pristine copy of ICU 4.6... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/deps/third_party/