icuSources/i18n/dayperiodrules.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 2016, International Business Machines
   6 * Corporation and others.  All Rights Reserved.
   7 *******************************************************************************
   8 * dayperiodrules.cpp
   9 *
  10 * created on: 2016-01-20
  11 * created by: kazede
  12 */
  13
  14 #include "dayperiodrules.h"
  15
  16 #include "unicode/ures.h"
  17 #include "charstr.h"
  18 #include "cstring.h"
  19 #include "ucln_in.h"
  20 #include "uhash.h"
  21 #include "umutex.h"
  22 #include "uresimp.h"
  23
  24
  25 U_NAMESPACE_BEGIN
  26
  27 namespace {
  28
  29 struct DayPeriodRulesData : public UMemory {
  30     DayPeriodRulesData() : localeToRuleSetNumMap(NULL), rules(NULL), maxRuleSetNum(0) {}
  31
  32     UHashtable *localeToRuleSetNumMap;
  33     DayPeriodRules *rules;
  34     int32_t maxRuleSetNum;
  35 } *data = NULL;
  36
  37 enum CutoffType {
  38     CUTOFF_TYPE_UNKNOWN = -1,
  39     CUTOFF_TYPE_BEFORE,
  40     CUTOFF_TYPE_AFTER,  // TODO: AFTER is deprecated in CLDR 29. Remove.
  41     CUTOFF_TYPE_FROM,
  42     CUTOFF_TYPE_AT
  43 };
  44
  45 } // namespace
  46
  47 struct DayPeriodRulesDataSink : public ResourceSink {
  48     DayPeriodRulesDataSink() {
  49         for (int32_t i = 0; i < UPRV_LENGTHOF(cutoffs); ++i) { cutoffs[i] = 0; }
  50     }
  51     virtual ~DayPeriodRulesDataSink();
  52
  53     virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) {
  54         ResourceTable dayPeriodData = value.getTable(errorCode);
  55         if (U_FAILURE(errorCode)) { return; }
  56
  57         for (int32_t i = 0; dayPeriodData.getKeyAndValue(i, key, value); ++i) {
  58             if (uprv_strcmp(key, "locales") == 0) {
  59                 ResourceTable locales = value.getTable(errorCode);
  60                 if (U_FAILURE(errorCode)) { return; }
  61
  62                 for (int32_t j = 0; locales.getKeyAndValue(j, key, value); ++j) {
  63                     UnicodeString setNum_str = value.getUnicodeString(errorCode);
  64                     int32_t setNum = parseSetNum(setNum_str, errorCode);
  65                     uhash_puti(data->localeToRuleSetNumMap, const_cast<char *>(key), setNum, &errorCode);
  66                 }
  67             } else if (uprv_strcmp(key, "rules") == 0) {
  68                 // Allocate one more than needed to skip [0]. See comment in parseSetNum().
  69                 data->rules = new DayPeriodRules[data->maxRuleSetNum + 1];
  70                 if (data->rules == NULL) {
  71                     errorCode = U_MEMORY_ALLOCATION_ERROR;
  72                     return;
  73                 }
  74                 ResourceTable rules = value.getTable(errorCode);
  75                 processRules(rules, key, value, errorCode);
  76                 if (U_FAILURE(errorCode)) { return; }
  77             }
  78         }
  79     }
  80
  81     void processRules(const ResourceTable &rules, const char *key,
  82                       ResourceValue &value, UErrorCode &errorCode) {
  83         if (U_FAILURE(errorCode)) { return; }
  84
  85         for (int32_t i = 0; rules.getKeyAndValue(i, key, value); ++i) {
  86             ruleSetNum = parseSetNum(key, errorCode);
  87             ResourceTable ruleSet = value.getTable(errorCode);
  88             if (U_FAILURE(errorCode)) { return; }
  89
  90             for (int32_t j = 0; ruleSet.getKeyAndValue(j, key, value); ++j) {
  91                 period = DayPeriodRules::getDayPeriodFromString(key);
  92                 if (period == DayPeriodRules::DAYPERIOD_UNKNOWN) {
  93                     errorCode = U_INVALID_FORMAT_ERROR;
  94                     return;
  95                 }
  96                 ResourceTable periodDefinition = value.getTable(errorCode);
  97                 if (U_FAILURE(errorCode)) { return; }
  98
  99                 for (int32_t k = 0; periodDefinition.getKeyAndValue(k, key, value); ++k) {
 100                     if (value.getType() == URES_STRING) {
 101                         // Key-value pairs (e.g. before{6:00}).
 102                         CutoffType type = getCutoffTypeFromString(key);
 103                         addCutoff(type, value.getUnicodeString(errorCode), errorCode);
 104                         if (U_FAILURE(errorCode)) { return; }
 105                     } else {
 106                         // Arrays (e.g. before{6:00, 24:00}).
 107                         cutoffType = getCutoffTypeFromString(key);
 108                         ResourceArray cutoffArray = value.getArray(errorCode);
 109                         if (U_FAILURE(errorCode)) { return; }
 110
 111                         int32_t length = cutoffArray.getSize();
 112                         for (int32_t l = 0; l < length; ++l) {
 113                             cutoffArray.getValue(l, value);
 114                             addCutoff(cutoffType, value.getUnicodeString(errorCode), errorCode);
 115                             if (U_FAILURE(errorCode)) { return; }
 116                         }
 117                     }
 118                 }
 119                 setDayPeriodForHoursFromCutoffs(errorCode);
 120                 for (int32_t k = 0; k < UPRV_LENGTHOF(cutoffs); ++k) {
 121                     cutoffs[k] = 0;
 122                 }
 123             }
 124
 125             if (!data->rules[ruleSetNum].allHoursAreSet()) {
 126                 errorCode = U_INVALID_FORMAT_ERROR;
 127                 return;
 128             }
 129         }
 130     }
 131
 132     // Members.
 133     int32_t cutoffs[25];  // [0] thru [24]: 24 is allowed in "before 24".
 134
 135     // "Path" to data.
 136     int32_t ruleSetNum;
 137     DayPeriodRules::DayPeriod period;
 138     CutoffType cutoffType;
 139
 140     // Helpers.
 141     static int32_t parseSetNum(const UnicodeString &setNumStr, UErrorCode &errorCode) {
 142         CharString cs;
 143         cs.appendInvariantChars(setNumStr, errorCode);
 144         return parseSetNum(cs.data(), errorCode);
 145     }
 146
 147     static int32_t parseSetNum(const char *setNumStr, UErrorCode &errorCode) {
 148         if (U_FAILURE(errorCode)) { return -1; }
 149
 150         if (uprv_strncmp(setNumStr, "set", 3) != 0) {
 151             errorCode = U_INVALID_FORMAT_ERROR;
 152             return -1;
 153         }
 154
 155         int32_t i = 3;
 156         int32_t setNum = 0;
 157         while (setNumStr[i] != 0) {
 158             int32_t digit = setNumStr[i] - '0';
 159             if (digit < 0 || 9 < digit) {
 160                 errorCode = U_INVALID_FORMAT_ERROR;
 161                 return -1;
 162             }
 163             setNum = 10 * setNum + digit;
 164             ++i;
 165         }
 166
 167         // Rule set number must not be zero. (0 is used to indicate "not found" by hashmap.)
 168         // Currently ICU data conveniently starts numbering rule sets from 1.
 169         if (setNum == 0) {
 170             errorCode = U_INVALID_FORMAT_ERROR;
 171             return -1;
 172         } else {
 173             return setNum;
 174         }
 175     }
 176
 177     void addCutoff(CutoffType type, const UnicodeString &hour_str, UErrorCode &errorCode) {
 178         if (U_FAILURE(errorCode)) { return; }
 179
 180         if (type == CUTOFF_TYPE_UNKNOWN) {
 181             errorCode = U_INVALID_FORMAT_ERROR;
 182             return;
 183         }
 184
 185         int32_t hour = parseHour(hour_str, errorCode);
 186         if (U_FAILURE(errorCode)) { return; }
 187
 188         cutoffs[hour] |= 1 << type;
 189     }
 190
 191     // Translate the cutoffs[] array to day period rules.
 192     void setDayPeriodForHoursFromCutoffs(UErrorCode &errorCode) {
 193         DayPeriodRules &rule = data->rules[ruleSetNum];
 194
 195         for (int32_t startHour = 0; startHour <= 24; ++startHour) {
 196             // AT cutoffs must be either midnight or noon.
 197             if (cutoffs[startHour] & (1 << CUTOFF_TYPE_AT)) {
 198                 if (startHour == 0 && period == DayPeriodRules::DAYPERIOD_MIDNIGHT) {
 199                     rule.fHasMidnight = TRUE;
 200                 } else if (startHour == 12 && period == DayPeriodRules::DAYPERIOD_NOON) {
 201                     rule.fHasNoon = TRUE;
 202                 } else {
 203                     errorCode = U_INVALID_FORMAT_ERROR;  // Bad data.
 204                     return;
 205                 }
 206             }
 207
 208             // FROM/AFTER and BEFORE must come in a pair.
 209             if (cutoffs[startHour] & (1 << CUTOFF_TYPE_FROM) ||
 210                     cutoffs[startHour] & (1 << CUTOFF_TYPE_AFTER)) {
 211                 for (int32_t hour = startHour + 1;; ++hour) {
 212                     if (hour == startHour) {
 213                         // We've gone around the array once and can't find a BEFORE.
 214                         errorCode = U_INVALID_FORMAT_ERROR;
 215                         return;
 216                     }
 217                     if (hour == 25) { hour = 0; }
 218                     if (cutoffs[hour] & (1 << CUTOFF_TYPE_BEFORE)) {
 219                         rule.add(startHour, hour, period);
 220                         break;
 221                     }
 222                 }
 223             }
 224         }
 225     }
 226
 227     // Translate "before" to CUTOFF_TYPE_BEFORE, for example.
 228     static CutoffType getCutoffTypeFromString(const char *type_str) {
 229         if (uprv_strcmp(type_str, "from") == 0) {
 230             return CUTOFF_TYPE_FROM;
 231         } else if (uprv_strcmp(type_str, "before") == 0) {
 232             return CUTOFF_TYPE_BEFORE;
 233         } else if (uprv_strcmp(type_str, "after") == 0) {
 234             return CUTOFF_TYPE_AFTER;
 235         } else if (uprv_strcmp(type_str, "at") == 0) {
 236             return CUTOFF_TYPE_AT;
 237         } else {
 238             return CUTOFF_TYPE_UNKNOWN;
 239         }
 240     }
 241
 242     // Gets the numerical value of the hour from the Unicode string.
 243     static int32_t parseHour(const UnicodeString &time, UErrorCode &errorCode) {
 244         if (U_FAILURE(errorCode)) {
 245             return 0;
 246         }
 247
 248         int32_t hourLimit = time.length() - 3;
 249         // `time` must look like "x:00" or "xx:00".
 250         // If length is wrong or `time` doesn't end with ":00", error out.
 251         if ((hourLimit != 1 && hourLimit != 2) ||
 252                 time[hourLimit] != 0x3A || time[hourLimit + 1] != 0x30 ||
 253                 time[hourLimit + 2] != 0x30) {
 254             errorCode = U_INVALID_FORMAT_ERROR;
 255             return 0;
 256         }
 257
 258         // If `time` doesn't begin with a number in [0, 24], error out.
 259         // Note: "24:00" is possible in "before 24:00".
 260         int32_t hour = time[0] - 0x30;
 261         if (hour < 0 || 9 < hour) {
 262             errorCode = U_INVALID_FORMAT_ERROR;
 263             return 0;
 264         }
 265         if (hourLimit == 2) {
 266             int32_t hourDigit2 = time[1] - 0x30;
 267             if (hourDigit2 < 0 || 9 < hourDigit2) {
 268                 errorCode = U_INVALID_FORMAT_ERROR;
 269                 return 0;
 270             }
 271             hour = hour * 10 + hourDigit2;
 272             if (hour > 24) {
 273                 errorCode = U_INVALID_FORMAT_ERROR;
 274                 return 0;
 275             }
 276         }
 277
 278         return hour;
 279     }
 280 };  // struct DayPeriodRulesDataSink
 281
 282 struct DayPeriodRulesCountSink : public ResourceSink {
 283     virtual ~DayPeriodRulesCountSink();
 284
 285     virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) {
 286         ResourceTable rules = value.getTable(errorCode);
 287         if (U_FAILURE(errorCode)) { return; }
 288
 289         for (int32_t i = 0; rules.getKeyAndValue(i, key, value); ++i) {
 290             int32_t setNum = DayPeriodRulesDataSink::parseSetNum(key, errorCode);
 291             if (setNum > data->maxRuleSetNum) {
 292                 data->maxRuleSetNum = setNum;
 293             }
 294         }
 295     }
 296 };
 297
 298 // Out-of-line virtual destructors.
 299 DayPeriodRulesDataSink::~DayPeriodRulesDataSink() {}
 300 DayPeriodRulesCountSink::~DayPeriodRulesCountSink() {}
 301
 302 namespace {
 303
 304 UInitOnce initOnce = U_INITONCE_INITIALIZER;
 305
 306 U_CFUNC UBool U_CALLCONV dayPeriodRulesCleanup() {
 307     delete[] data->rules;
 308     uhash_close(data->localeToRuleSetNumMap);
 309     delete data;
 310     data = NULL;
 311     return TRUE;
 312 }
 313
 314 }  // namespace
 315
 316 void U_CALLCONV DayPeriodRules::load(UErrorCode &errorCode) {
 317     if (U_FAILURE(errorCode)) {
 318         return;
 319     }
 320
 321     data = new DayPeriodRulesData();
 322     data->localeToRuleSetNumMap = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &errorCode);
 323     LocalUResourceBundlePointer rb_dayPeriods(ures_openDirect(NULL, "dayPeriods", &errorCode));
 324
 325     // Get the largest rule set number (so we allocate enough objects).
 326     DayPeriodRulesCountSink countSink;
 327     ures_getAllItemsWithFallback(rb_dayPeriods.getAlias(), "rules", countSink, errorCode);
 328
 329     // Populate rules.
 330     DayPeriodRulesDataSink sink;
 331     ures_getAllItemsWithFallback(rb_dayPeriods.getAlias(), "", sink, errorCode);
 332
 333     ucln_i18n_registerCleanup(UCLN_I18N_DAYPERIODRULES, dayPeriodRulesCleanup);
 334 }
 335
 336 const DayPeriodRules *DayPeriodRules::getInstance(const Locale &locale, UErrorCode &errorCode) {
 337     umtx_initOnce(initOnce, DayPeriodRules::load, errorCode);
 338
 339     // If the entire day period rules data doesn't conform to spec (even if the part we want
 340     // does), return NULL.
 341     if(U_FAILURE(errorCode)) { return NULL; }
 342
 343     const char *localeCode = locale.getBaseName();
 344     char name[ULOC_FULLNAME_CAPACITY];
 345     char parentName[ULOC_FULLNAME_CAPACITY];
 346
 347     if (uprv_strlen(localeCode) < ULOC_FULLNAME_CAPACITY) {
 348         uprv_strcpy(name, localeCode);
 349
 350         // Treat empty string as root.
 351         if (*name == '\0') {
 352             uprv_strcpy(name, "root");
 353         }
 354     } else {
 355         errorCode = U_BUFFER_OVERFLOW_ERROR;
 356         return NULL;
 357     }
 358
 359     int32_t ruleSetNum = 0;  // NB there is no rule set 0 and 0 is returned upon lookup failure.
 360     while (*name != '\0') {
 361         ruleSetNum = uhash_geti(data->localeToRuleSetNumMap, name);
 362         if (ruleSetNum == 0) {
 363             // name and parentName can't be the same pointer, so fill in parent then copy to child.
 364             uloc_getParent(name, parentName, ULOC_FULLNAME_CAPACITY, &errorCode);
 365             if (*parentName == '\0') {
 366                 // Saves a lookup in the hash table.
 367                 break;
 368             }
 369             uprv_strcpy(name, parentName);
 370         } else {
 371             break;
 372         }
 373     }
 374
 375     if (ruleSetNum <= 0 || data->rules[ruleSetNum].getDayPeriodForHour(0) == DAYPERIOD_UNKNOWN) {
 376         // If day period for hour 0 is UNKNOWN then day period for all hours are UNKNOWN.
 377         // Data doesn't exist even with fallback.
 378         return NULL;
 379     } else {
 380         return &data->rules[ruleSetNum];
 381     }
 382 }
 383
 384 DayPeriodRules::DayPeriodRules() : fHasMidnight(FALSE), fHasNoon(FALSE) {
 385     for (int32_t i = 0; i < 24; ++i) {
 386         fDayPeriodForHour[i] = DayPeriodRules::DAYPERIOD_UNKNOWN;
 387     }
 388 }
 389
 390 double DayPeriodRules::getMidPointForDayPeriod(
 391         DayPeriodRules::DayPeriod dayPeriod, UErrorCode &errorCode) const {
 392     if (U_FAILURE(errorCode)) { return -1; }
 393
 394     int32_t startHour = getStartHourForDayPeriod(dayPeriod, errorCode);
 395     int32_t endHour = getEndHourForDayPeriod(dayPeriod, errorCode);
 396     // Can't obtain startHour or endHour; bail out.
 397     if (U_FAILURE(errorCode)) { return -1; }
 398
 399     double midPoint = (startHour + endHour) / 2.0;
 400
 401     if (startHour > endHour) {
 402         // dayPeriod wraps around midnight. Shift midPoint by 12 hours, in the direction that
 403         // lands it in [0, 24).
 404         midPoint += 12;
 405         if (midPoint >= 24) {
 406             midPoint -= 24;
 407         }
 408     }
 409
 410     return midPoint;
 411 }
 412
 413 int32_t DayPeriodRules::getStartHourForDayPeriod(
 414         DayPeriodRules::DayPeriod dayPeriod, UErrorCode &errorCode) const {
 415     if (U_FAILURE(errorCode)) { return -1; }
 416
 417     if (dayPeriod == DAYPERIOD_MIDNIGHT) { return 0; }
 418     if (dayPeriod == DAYPERIOD_NOON) { return 12; }
 419
 420     if (fDayPeriodForHour[0] == dayPeriod && fDayPeriodForHour[23] == dayPeriod) {
 421         // dayPeriod wraps around midnight. Start hour is later than end hour.
 422         for (int32_t i = 22; i >= 1; --i) {
 423             if (fDayPeriodForHour[i] != dayPeriod) {
 424                 return (i + 1);
 425             }
 426         }
 427     } else {
 428         for (int32_t i = 0; i <= 23; ++i) {
 429             if (fDayPeriodForHour[i] == dayPeriod) {
 430                 return i;
 431             }
 432         }
 433     }
 434
 435     // dayPeriod doesn't exist in rule set; set error and exit.
 436     errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 437     return -1;
 438 }
 439
 440 int32_t DayPeriodRules::getEndHourForDayPeriod(
 441         DayPeriodRules::DayPeriod dayPeriod, UErrorCode &errorCode) const {
 442     if (U_FAILURE(errorCode)) { return -1; }
 443
 444     if (dayPeriod == DAYPERIOD_MIDNIGHT) { return 0; }
 445     if (dayPeriod == DAYPERIOD_NOON) { return 12; }
 446
 447     if (fDayPeriodForHour[0] == dayPeriod && fDayPeriodForHour[23] == dayPeriod) {
 448         // dayPeriod wraps around midnight. End hour is before start hour.
 449         for (int32_t i = 1; i <= 22; ++i) {
 450             if (fDayPeriodForHour[i] != dayPeriod) {
 451                 // i o'clock is when a new period starts, therefore when the old period ends.
 452                 return i;
 453             }
 454         }
 455     } else {
 456         for (int32_t i = 23; i >= 0; --i) {
 457             if (fDayPeriodForHour[i] == dayPeriod) {
 458                 return (i + 1);
 459             }
 460         }
 461     }
 462
 463     // dayPeriod doesn't exist in rule set; set error and exit.
 464     errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 465     return -1;
 466 }
 467
 468 DayPeriodRules::DayPeriod DayPeriodRules::getDayPeriodFromString(const char *type_str) {
 469     if (uprv_strcmp(type_str, "midnight") == 0) {
 470         return DAYPERIOD_MIDNIGHT;
 471     } else if (uprv_strcmp(type_str, "noon") == 0) {
 472         return DAYPERIOD_NOON;
 473     } else if (uprv_strcmp(type_str, "morning1") == 0) {
 474         return DAYPERIOD_MORNING1;
 475     } else if (uprv_strcmp(type_str, "afternoon1") == 0) {
 476         return DAYPERIOD_AFTERNOON1;
 477     } else if (uprv_strcmp(type_str, "evening1") == 0) {
 478         return DAYPERIOD_EVENING1;
 479     } else if (uprv_strcmp(type_str, "night1") == 0) {
 480         return DAYPERIOD_NIGHT1;
 481     } else if (uprv_strcmp(type_str, "morning2") == 0) {
 482         return DAYPERIOD_MORNING2;
 483     } else if (uprv_strcmp(type_str, "afternoon2") == 0) {
 484         return DAYPERIOD_AFTERNOON2;
 485     } else if (uprv_strcmp(type_str, "evening2") == 0) {
 486         return DAYPERIOD_EVENING2;
 487     } else if (uprv_strcmp(type_str, "night2") == 0) {
 488         return DAYPERIOD_NIGHT2;
 489     } else if (uprv_strcmp(type_str, "am") == 0) {
 490         return DAYPERIOD_AM;
 491     } else if (uprv_strcmp(type_str, "pm") == 0) {
 492         return DAYPERIOD_PM;
 493     } else {
 494         return DAYPERIOD_UNKNOWN;
 495     }
 496 }
 497
 498 void DayPeriodRules::add(int32_t startHour, int32_t limitHour, DayPeriod period) {
 499     for (int32_t i = startHour; i != limitHour; ++i) {
 500         if (i == 24) { i = 0; }
 501         fDayPeriodForHour[i] = period;
 502     }
 503 }
 504
 505 UBool DayPeriodRules::allHoursAreSet() {
 506     for (int32_t i = 0; i < 24; ++i) {
 507         if (fDayPeriodForHour[i] == DAYPERIOD_UNKNOWN) { return FALSE; }
 508     }
 509
 510     return TRUE;
 511 }
 512
 513
 514
 515 U_NAMESPACE_END