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
25U_NAMESPACE_BEGIN
26
27namespace {
28
29struct 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
37enum 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
47struct 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
282struct 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.
299DayPeriodRulesDataSink::~DayPeriodRulesDataSink() {}
300DayPeriodRulesCountSink::~DayPeriodRulesCountSink() {}
301
302namespace {
303
304UInitOnce initOnce = U_INITONCE_INITIALIZER;
305
306U_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
316void 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
336const 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
384DayPeriodRules::DayPeriodRules() : fHasMidnight(FALSE), fHasNoon(FALSE) {
385 for (int32_t i = 0; i < 24; ++i) {
386 fDayPeriodForHour[i] = DayPeriodRules::DAYPERIOD_UNKNOWN;
387 }
388}
389
390double 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
413int32_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
440int32_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
468DayPeriodRules::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
498void 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
505UBool 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
515U_NAMESPACE_END
516