• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 {
DayPeriodRulesData__anon3c67e0510111::DayPeriodRulesData30     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 {
DayPeriodRulesDataSinkDayPeriodRulesDataSink48     DayPeriodRulesDataSink() {
49         for (int32_t i = 0; i < UPRV_LENGTHOF(cutoffs); ++i) { cutoffs[i] = 0; }
50     }
51     virtual ~DayPeriodRulesDataSink();
52 
putDayPeriodRulesDataSink53     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 
processRulesDayPeriodRulesDataSink81     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.
parseSetNumDayPeriodRulesDataSink141     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 
parseSetNumDayPeriodRulesDataSink147     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 
addCutoffDayPeriodRulesDataSink177     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.
setDayPeriodForHoursFromCutoffsDayPeriodRulesDataSink192     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.
getCutoffTypeFromStringDayPeriodRulesDataSink228     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.
parseHourDayPeriodRulesDataSink243     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 
putDayPeriodRulesCountSink285     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.
~DayPeriodRulesDataSink()299 DayPeriodRulesDataSink::~DayPeriodRulesDataSink() {}
~DayPeriodRulesCountSink()300 DayPeriodRulesCountSink::~DayPeriodRulesCountSink() {}
301 
302 namespace {
303 
304 UInitOnce initOnce = U_INITONCE_INITIALIZER;
305 
dayPeriodRulesCleanup()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 
load(UErrorCode & errorCode)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 
getInstance(const Locale & locale,UErrorCode & errorCode)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 
DayPeriodRules()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 
getMidPointForDayPeriod(DayPeriodRules::DayPeriod dayPeriod,UErrorCode & errorCode) const390 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 
getStartHourForDayPeriod(DayPeriodRules::DayPeriod dayPeriod,UErrorCode & errorCode) const413 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 
getEndHourForDayPeriod(DayPeriodRules::DayPeriod dayPeriod,UErrorCode & errorCode) const440 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 
getDayPeriodFromString(const char * type_str)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 
add(int32_t startHour,int32_t limitHour,DayPeriod period)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 
allHoursAreSet()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
516