• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "date_time_format.h"
16 #include <algorithm>
17 #include <cmath>
18 #include "ohos/init_data.h"
19 #include "locale_config.h"
20 
21 namespace OHOS {
22 namespace Global {
23 namespace I18n {
24 using namespace icu;
25 
26 bool DateTimeFormat::icuInitialized = DateTimeFormat::Init();
27 
28 std::map<std::string, DateFormat::EStyle> DateTimeFormat::dateTimeStyle = {
29     { "full", DateFormat::EStyle::kFull },
30     { "long", DateFormat::EStyle::kLong },
31     { "medium", DateFormat::EStyle::kMedium },
32     { "short", DateFormat::EStyle::kShort }
33 };
34 
DateTimeFormat(const std::vector<std::string> & localeTags,std::map<std::string,std::string> & configs)35 DateTimeFormat::DateTimeFormat(const std::vector<std::string> &localeTags, std::map<std::string, std::string> &configs)
36 {
37     UErrorCode status = U_ZERO_ERROR;
38     std::unique_ptr<icu::LocaleBuilder> builder = nullptr;
39     builder = std::make_unique<LocaleBuilder>();
40     ParseConfigsPartOne(configs);
41     ParseConfigsPartTwo(configs);
42     for (size_t i = 0; i < localeTags.size(); i++) {
43         std::string curLocale = localeTags[i];
44         locale = Locale::forLanguageTag(StringPiece(curLocale), status);
45         if (LocaleInfo::allValidLocales.count(locale.getLanguage()) > 0) {
46             InitWithLocale(curLocale, configs);
47             if (!dateFormat) {
48                 delete localeInfo;
49                 localeInfo = nullptr;
50                 continue;
51             }
52             break;
53         }
54     }
55     if (!localeInfo || !dateFormat) {
56         InitWithDefaultLocale(configs);
57     }
58 }
59 
~DateTimeFormat()60 DateTimeFormat::~DateTimeFormat()
61 {
62     if (dateIntvFormat != nullptr) {
63         delete dateIntvFormat;
64         dateIntvFormat = nullptr;
65     }
66     if (calendar != nullptr) {
67         delete calendar;
68         calendar = nullptr;
69     }
70     if (dateFormat != nullptr) {
71         delete dateFormat;
72         dateFormat = nullptr;
73     }
74     if (localeInfo != nullptr) {
75         delete localeInfo;
76         localeInfo = nullptr;
77     }
78 }
79 
InitWithLocale(const std::string & curLocale,std::map<std::string,std::string> & configs)80 void DateTimeFormat::InitWithLocale(const std::string &curLocale, std::map<std::string, std::string> &configs)
81 {
82     UErrorCode status = U_ZERO_ERROR;
83     localeInfo = new LocaleInfo(curLocale, configs);
84     locale = localeInfo->GetLocale();
85     localeTag = localeInfo->GetBaseName();
86     if (hourCycle.empty()) {
87         hourCycle = localeInfo->GetHourCycle();
88     }
89     if (hour12.empty() && hourCycle.empty()) {
90         bool is24HourClock = LocaleConfig::Is24HourClock();
91         if (is24HourClock) {
92             hour12 = "false";
93         }
94     }
95     ComputeHourCycleChars();
96     ComputeSkeleton();
97     if (!configs.size()) {
98         InitDateFormatWithoutConfigs(status);
99     } else {
100         InitDateFormat(status);
101     }
102     calendar = Calendar::createInstance(locale, status);
103 }
104 
InitWithDefaultLocale(std::map<std::string,std::string> & configs)105 void DateTimeFormat::InitWithDefaultLocale(std::map<std::string, std::string> &configs)
106 {
107     if (localeInfo != nullptr) {
108         delete localeInfo;
109         localeInfo = nullptr;
110     }
111     if (dateFormat != nullptr) {
112         delete dateFormat;
113         dateFormat = nullptr;
114     }
115     InitWithLocale(LocaleConfig::GetSystemLocale(), configs);
116 }
117 
InitDateFormatWithoutConfigs(UErrorCode & status)118 void DateTimeFormat::InitDateFormatWithoutConfigs(UErrorCode &status)
119 {
120     dateFormat = DateFormat::createDateInstance(DateFormat::SHORT, locale);
121     SimpleDateFormat *simDateFormat = static_cast<SimpleDateFormat*>(dateFormat);
122     if (simDateFormat != nullptr) {
123         simDateFormat->toPattern(pattern);
124     }
125     dateIntvFormat = DateIntervalFormat::createInstance(pattern, locale, status);
126 }
127 
FixPatternPartOne()128 void DateTimeFormat::FixPatternPartOne()
129 {
130     if (hour12 == "true") {
131         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("H")),
132             icu::UnicodeString::fromUTF8(StringPiece("h")));
133         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("k")),
134             icu::UnicodeString::fromUTF8(StringPiece("h")));
135         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("K")),
136             icu::UnicodeString::fromUTF8(StringPiece("h")));
137     } else if (hour12 == "false") {
138         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("h")),
139             icu::UnicodeString::fromUTF8(StringPiece("H")));
140         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("k")),
141             icu::UnicodeString::fromUTF8(StringPiece("H")));
142         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("K")),
143             icu::UnicodeString::fromUTF8(StringPiece("H")));
144         removeAmPmChar();
145     } else if (hourCycle != "") {
146         FixPatternPartTwo();
147     }
148 }
149 
FixPatternPartTwo()150 void DateTimeFormat::FixPatternPartTwo()
151 {
152     if (hourCycle == "h11") {
153         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("h")),
154             icu::UnicodeString::fromUTF8(StringPiece("k")));
155         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("H")),
156             icu::UnicodeString::fromUTF8(StringPiece("k")));
157         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("K")),
158             icu::UnicodeString::fromUTF8(StringPiece("k")));
159     } else if (hourCycle == "h12") {
160         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("H")),
161             icu::UnicodeString::fromUTF8(StringPiece("h")));
162         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("k")),
163             icu::UnicodeString::fromUTF8(StringPiece("h")));
164         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("K")),
165             icu::UnicodeString::fromUTF8(StringPiece("h")));
166     } else if (hourCycle == "h23") {
167         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("h")),
168             icu::UnicodeString::fromUTF8(StringPiece("K")));
169         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("H")),
170             icu::UnicodeString::fromUTF8(StringPiece("K")));
171         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("k")),
172             icu::UnicodeString::fromUTF8(StringPiece("K")));
173         removeAmPmChar();
174     } else if (hourCycle == "h24") {
175         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("h")),
176             icu::UnicodeString::fromUTF8(StringPiece("H")));
177         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("k")),
178             icu::UnicodeString::fromUTF8(StringPiece("H")));
179         pattern.findAndReplace(icu::UnicodeString::fromUTF8(StringPiece("K")),
180             icu::UnicodeString::fromUTF8(StringPiece("H")));
181         removeAmPmChar();
182     }
183 }
184 
removeAmPmChar()185 void DateTimeFormat::removeAmPmChar()
186 {
187     std::string patternString = "";
188     pattern.toUTF8String(patternString);
189     size_t amPmCharStartIdx = 0;
190     size_t amPmCharEndIdx = 0;
191     for (size_t i = 0; i < patternString.length(); i++) {
192         if (patternString[i] != 'a') {
193             continue;
194         }
195         if ((i + 1) < patternString.length() && patternString[i + 1] == 't') {
196             continue;
197         }
198         if (!i) {
199             amPmCharStartIdx = i;
200         } else {
201             amPmCharStartIdx = i - 1;
202             while (amPmCharStartIdx > 0 && patternString[amPmCharStartIdx] == ' ') {
203                 amPmCharStartIdx -= 1;
204             }
205             if (amPmCharStartIdx || patternString[amPmCharStartIdx] != ' ') {
206                 amPmCharStartIdx += 1;
207             }
208         }
209         amPmCharEndIdx = i + 1;
210         while (amPmCharEndIdx < patternString.length() && patternString[amPmCharEndIdx] == ' ') {
211             amPmCharEndIdx += 1;
212         }
213         break;
214     }
215     size_t length = amPmCharEndIdx - amPmCharStartIdx;
216     if (length) {
217         if (!amPmCharStartIdx || amPmCharEndIdx == patternString.length()) {
218             patternString = patternString.replace(amPmCharStartIdx, length, "");
219         } else {
220             patternString = patternString.replace(amPmCharStartIdx, length, " ");
221         }
222         pattern = icu::UnicodeString(patternString.data(), patternString.length());
223     }
224 }
225 
InitDateFormat(UErrorCode & status)226 void DateTimeFormat::InitDateFormat(UErrorCode &status)
227 {
228     if (!dateStyle.empty() || !timeStyle.empty()) {
229         DateFormat::EStyle dateStyleValue = DateFormat::EStyle::kNone;
230         DateFormat::EStyle timeStyleValue = DateFormat::EStyle::kNone;
231         if (!dateStyle.empty()) {
232             dateStyleValue = dateTimeStyle[dateStyle];
233         }
234         if (!timeStyle.empty()) {
235             timeStyleValue = dateTimeStyle[timeStyle];
236         }
237         dateFormat = DateFormat::createDateTimeInstance(dateStyleValue, timeStyleValue, locale);
238         SimpleDateFormat *simDateFormat = static_cast<SimpleDateFormat*>(dateFormat);
239         if (simDateFormat != nullptr) {
240             simDateFormat->toPattern(pattern);
241         }
242         FixPatternPartOne();
243         delete dateFormat;
244         dateFormat = new SimpleDateFormat(pattern, locale, status);
245     } else {
246         auto patternGenerator =
247             std::unique_ptr<DateTimePatternGenerator>(DateTimePatternGenerator::createInstance(locale, status));
248         ComputePattern();
249         pattern =
250             patternGenerator->replaceFieldTypes(patternGenerator->getBestPattern(pattern, status), pattern, status);
251         pattern = patternGenerator->getBestPattern(pattern, status);
252         dateFormat = new SimpleDateFormat(pattern, locale, status);
253     }
254     dateIntvFormat = DateIntervalFormat::createInstance(pattern, locale, status);
255 }
256 
ParseConfigsPartOne(std::map<std::string,std::string> & configs)257 void DateTimeFormat::ParseConfigsPartOne(std::map<std::string, std::string> &configs)
258 {
259     if (configs.count("dateStyle") > 0) {
260         dateStyle = configs["dateStyle"];
261     }
262     if (configs.count("timeStyle") > 0) {
263         timeStyle = configs["timeStyle"];
264     }
265     if (configs.count("year") > 0) {
266         year = configs["year"];
267     }
268     if (configs.count("month") > 0) {
269         month = configs["month"];
270     }
271     if (configs.count("day") > 0) {
272         day = configs["day"];
273     }
274     if (configs.count("hour") > 0) {
275         hour = configs["hour"];
276     }
277     if (configs.count("minute") > 0) {
278         minute = configs["minute"];
279     }
280     if (configs.count("second") > 0) {
281         second = configs["second"];
282     }
283 }
284 
ParseConfigsPartTwo(std::map<std::string,std::string> & configs)285 void DateTimeFormat::ParseConfigsPartTwo(std::map<std::string, std::string> &configs)
286 {
287     if (configs.count("hourCycle") > 0) {
288         hourCycle = configs["hourCycle"];
289     }
290     if (configs.count("timeZone") > 0) {
291         timeZone = configs["timeZone"];
292     }
293     if (configs.count("numberingSystem") > 0) {
294         numberingSystem = configs["numberingSystem"];
295     }
296     if (configs.count("hour12") > 0) {
297         hour12 = configs["hour12"];
298     }
299     if (configs.count("weekday") > 0) {
300         weekday = configs["weekday"];
301     }
302     if (configs.count("era") > 0) {
303         era = configs["era"];
304     }
305     if (configs.count("timeZoneName") > 0) {
306         timeZoneName = configs["timeZoneName"];
307     }
308     if (configs.count("dayPeriod") > 0) {
309         dayPeriod = configs["dayPeriod"];
310     }
311     if (configs.count("localeMatcher") > 0) {
312         localeMatcher = configs["localeMatcher"];
313     }
314     if (configs.count("formatMatcher") > 0) {
315         formatMatcher = configs["formatMatcher"];
316     }
317 }
318 
ComputeSkeleton()319 void DateTimeFormat::ComputeSkeleton()
320 {
321     if (year.empty() && month.empty() && day.empty() && hour.empty() && minute.empty() && second.empty()) {
322         pattern.append("yMd");
323     }
324     AddOptions(year, yearChar);
325     AddOptions(month, monthChar);
326     AddOptions(day, dayChar);
327     AddOptions(hour, hourChar);
328     AddOptions(minute, minuteChar);
329     AddOptions(second, secondChar);
330     if ((hourCycle == "h12" || hourCycle == "h11" || hour12 == "true") && !hour.empty()) {
331         pattern.append(amPmChar);
332     }
333     AddOptions(timeZoneName, timeZoneChar);
334     AddOptions(weekday, weekdayChar);
335     AddOptions(era, eraChar);
336 }
337 
AddOptions(std::string option,char16_t optionChar)338 void DateTimeFormat::AddOptions(std::string option, char16_t optionChar)
339 {
340     if (!option.empty()) {
341         pattern.append(optionChar);
342     }
343 }
344 
ComputeHourCycleChars()345 void DateTimeFormat::ComputeHourCycleChars()
346 {
347     if (!hour12.empty()) {
348         if (hour12 == "true") {
349             hourNumericString = "h";
350             hourTwoDigitString = "hh";
351         } else {
352             hourNumericString = "H";
353             hourTwoDigitString = "HH";
354         }
355     } else {
356         if (hourCycle == "h11") {
357             hourNumericString = "K";
358             hourTwoDigitString = "KK";
359         } else if (hourCycle == "h12") {
360             hourNumericString = "h";
361             hourTwoDigitString = "hh";
362         } else if (hourCycle == "h23") {
363             hourNumericString = "H";
364             hourTwoDigitString = "HH";
365         } else if (hourCycle == "h24") {
366             hourNumericString = "k";
367             hourTwoDigitString = "kk";
368         }
369     }
370 }
371 
ComputePattern()372 void DateTimeFormat::ComputePattern()
373 {
374     ComputePartOfPattern(year, yearChar, "yy", "Y");
375     ComputePartOfPattern(day, dayChar, "dd", "d");
376     ComputePartOfPattern(hour, hourChar, hourTwoDigitString, hourNumericString);
377     ComputePartOfPattern(minute, minuteChar, "mm", "mm");
378     ComputePartOfPattern(second, secondChar, "ss", "ss");
379     if (!month.empty()) {
380         UnicodeString monthOfPattern = UnicodeString(monthChar);
381         int32_t length = monthOfPattern.length();
382         if (month == "numeric" && length != NUMERIC_LENGTH) {
383             pattern.findAndReplace(monthOfPattern, UnicodeString::fromUTF8(StringPiece("M")));
384         } else if (month == "2-digit" && length != TWO_DIGIT_LENGTH) {
385             pattern.findAndReplace(monthOfPattern, UnicodeString::fromUTF8(StringPiece("MM")));
386         } else if (month == "long" && length != LONG_LENGTH) {
387             pattern.findAndReplace(monthOfPattern, UnicodeString::fromUTF8(StringPiece("MMMM")));
388         } else if (month == "short" && length != SHORT_LENGTH) {
389             pattern.findAndReplace(monthOfPattern, UnicodeString::fromUTF8(StringPiece("MMM")));
390         } else if (month == "narrow" && length != NARROW_LENGTH) {
391             pattern.findAndReplace(monthOfPattern, UnicodeString::fromUTF8(StringPiece("MMMMM")));
392         }
393     }
394     if (!timeZoneName.empty()) {
395         UnicodeString timeZoneOfPattern = UnicodeString(timeZoneChar);
396         if (timeZoneName == "long") {
397             pattern.findAndReplace(timeZoneOfPattern, UnicodeString::fromUTF8(StringPiece("zzzz")));
398         } else if (timeZoneName == "short") {
399             pattern.findAndReplace(timeZoneOfPattern, UnicodeString::fromUTF8(StringPiece("O")));
400         }
401     }
402 
403     ComputeWeekdayOrEraOfPattern(weekday, weekdayChar, "EEEE", "E", "EEEEE");
404     ComputeWeekdayOrEraOfPattern(era, eraChar, "GGGG", "G", "GGGGG");
405 }
406 
ComputePartOfPattern(std::string option,char16_t character,std::string twoDigitChar,std::string numericChar)407 void DateTimeFormat::ComputePartOfPattern(std::string option, char16_t character, std::string twoDigitChar,
408     std::string numericChar)
409 {
410     if (!option.empty()) {
411         UnicodeString curPartOfPattern = UnicodeString(character);
412         int32_t length = curPartOfPattern.length();
413         if (option == "2-digit" && length == TWO_DIGIT_LENGTH) {
414             pattern.findAndReplace(curPartOfPattern, UnicodeString::fromUTF8(StringPiece(twoDigitChar)));
415         } else if (option == "numeric" && length == NUMERIC_LENGTH) {
416             pattern.findAndReplace(curPartOfPattern, UnicodeString::fromUTF8(StringPiece(numericChar)));
417         }
418     }
419 }
420 
ComputeWeekdayOrEraOfPattern(std::string option,char16_t character,std::string longChar,std::string shortChar,std::string narrowChar)421 void DateTimeFormat::ComputeWeekdayOrEraOfPattern(std::string option, char16_t character, std::string longChar,
422     std::string shortChar, std::string narrowChar)
423 {
424     if (!option.empty()) {
425         UnicodeString curPartOfPattern = UnicodeString(character);
426         int32_t length = curPartOfPattern.length();
427         if (option == "long" && length != LONG_ERA_LENGTH) {
428             pattern.findAndReplace(curPartOfPattern, UnicodeString::fromUTF8(StringPiece(longChar)));
429         } else if (option == "short" && length != SHORT_ERA_LENGTH) {
430             pattern.findAndReplace(curPartOfPattern, UnicodeString::fromUTF8(StringPiece(shortChar)));
431         } else if (option == "narrow" && length != NARROW_LENGTH) {
432             pattern.findAndReplace(curPartOfPattern, UnicodeString::fromUTF8(StringPiece(narrowChar)));
433         }
434     }
435 }
436 
GetArrayValue(int64_t * dateArray,size_t index,size_t size)437 int64_t DateTimeFormat::GetArrayValue(int64_t *dateArray, size_t index, size_t size)
438 {
439     if (index < size) {
440         return dateArray[index];
441     } else {
442         return 0;
443     }
444 }
445 
Format(int64_t * date,size_t size)446 std::string DateTimeFormat::Format(int64_t *date, size_t size)
447 {
448     UErrorCode status = U_ZERO_ERROR;
449     std::string result;
450     UnicodeString dateString;
451     int64_t year = GetArrayValue(date, YEAR_INDEX, size);
452     int64_t month = GetArrayValue(date, MONTH_INDEX, size);
453     int64_t day = GetArrayValue(date, DAY_INDEX, size);
454     int64_t hour = GetArrayValue(date, HOUR_INDEX, size);
455     int64_t minute = GetArrayValue(date, MINUTE_INDEX, size);
456     int64_t second = GetArrayValue(date, SECOND_INDEX, size);
457     calendar->clear();
458     calendar->set(year, month, day, hour, minute, second);
459     if (!timeZone.empty()) {
460         UDate timestamp = calendar->getTime(status);
461         auto zone = std::unique_ptr<TimeZone>(TimeZone::createTimeZone(timeZone.c_str()));
462         calendar->setTimeZone(*zone);
463         dateFormat->setTimeZone(*zone);
464         calendar->setTime(timestamp, status);
465     }
466     dateFormat->format(calendar->getTime(status), dateString, status);
467     dateString.toUTF8String(result);
468     return result;
469 }
470 
FormatRange(int64_t * fromDate,size_t fromDateSize,int64_t * toDate,size_t toDateSize)471 std::string DateTimeFormat::FormatRange(int64_t *fromDate, size_t fromDateSize, int64_t *toDate, size_t toDateSize)
472 {
473     UErrorCode status = U_ZERO_ERROR;
474     std::string result;
475     UnicodeString dateString;
476     int64_t year = GetArrayValue(fromDate, YEAR_INDEX, fromDateSize);
477     int64_t month = GetArrayValue(fromDate, MONTH_INDEX, fromDateSize);
478     int64_t day = GetArrayValue(fromDate, DAY_INDEX, fromDateSize);
479     int64_t hour = GetArrayValue(fromDate, HOUR_INDEX, fromDateSize);
480     int64_t minute = GetArrayValue(fromDate, MINUTE_INDEX, fromDateSize);
481     int64_t second = GetArrayValue(fromDate, SECOND_INDEX, fromDateSize);
482     calendar->clear();
483     calendar->set(year, month, day, hour, minute, second);
484     if (!timeZone.empty()) {
485         UDate timestamp = calendar->getTime(status);
486         auto zone = std::unique_ptr<TimeZone>(TimeZone::createTimeZone(timeZone.c_str()));
487         calendar->setTimeZone(*zone);
488         dateIntvFormat->setTimeZone(*zone);
489         calendar->setTime(timestamp, status);
490     }
491     year = GetArrayValue(toDate, YEAR_INDEX, toDateSize);
492     month = GetArrayValue(toDate, MONTH_INDEX, toDateSize);
493     day = GetArrayValue(toDate, DAY_INDEX, toDateSize);
494     hour = GetArrayValue(toDate, HOUR_INDEX, toDateSize);
495     minute = GetArrayValue(toDate, MINUTE_INDEX, toDateSize);
496     second = GetArrayValue(toDate, SECOND_INDEX, toDateSize);
497     auto toCalendar = std::unique_ptr<Calendar>(Calendar::createInstance(locale, status));
498     toCalendar->clear();
499     toCalendar->set(year, month, day, hour, minute, second);
500     if (!timeZone.empty()) {
501         UDate timestamp = toCalendar->getTime(status);
502         auto zone = std::unique_ptr<TimeZone>(TimeZone::createTimeZone(timeZone.c_str()));
503         toCalendar->setTimeZone(*zone);
504         dateIntvFormat->setTimeZone(*zone);
505         toCalendar->setTime(timestamp, status);
506     }
507     FieldPosition pos = 0;
508     dateIntvFormat->format(*calendar, *toCalendar, dateString, pos, status);
509     dateString.toUTF8String(result);
510     return result;
511 }
512 
GetResolvedOptions(std::map<std::string,std::string> & map)513 void DateTimeFormat::GetResolvedOptions(std::map<std::string, std::string> &map)
514 {
515     UErrorCode status = U_ZERO_ERROR;
516     map.insert(std::make_pair("locale", localeTag));
517     if (!(localeInfo->GetCalendar()).empty()) {
518         map.insert(std::make_pair("calendar", localeInfo->GetCalendar()));
519     } else {
520         map.insert(std::make_pair("calendar", calendar->getType()));
521     }
522     if (!dateStyle.empty()) {
523         map.insert(std::make_pair("dateStyle", dateStyle));
524     }
525     if (!timeStyle.empty()) {
526         map.insert(std::make_pair("timeStyle", timeStyle));
527     }
528     if (!hourCycle.empty()) {
529         map.insert(std::make_pair("hourCycle", hourCycle));
530     } else if (!(localeInfo->GetHourCycle()).empty()) {
531         map.insert(std::make_pair("hourCycle", localeInfo->GetHourCycle()));
532     }
533     if (!timeZone.empty()) {
534         map.insert(std::make_pair("timeZone", timeZone));
535     } else {
536         UnicodeString timeZoneID("");
537         std::string timeZoneString;
538         dateFormat->getTimeZone().getID(timeZoneID).toUTF8String(timeZoneString);
539         map.insert(std::make_pair("timeZone", timeZoneString));
540     }
541     if (!timeZoneName.empty()) {
542         map.insert(std::make_pair("timeZoneName", timeZoneName));
543     }
544     if (!numberingSystem.empty()) {
545         map.insert(std::make_pair("numberingSystem", numberingSystem));
546     } else if (!(localeInfo->GetNumberingSystem()).empty()) {
547         map.insert(std::make_pair("numberingSystem", localeInfo->GetNumberingSystem()));
548     } else {
549         auto numSys = std::unique_ptr<NumberingSystem>(NumberingSystem::createInstance(locale, status));
550         map.insert(std::make_pair("numberingSystem", numSys->getName()));
551     }
552     GetAdditionalResolvedOptions(map);
553 }
554 
GetAdditionalResolvedOptions(std::map<std::string,std::string> & map)555 void DateTimeFormat::GetAdditionalResolvedOptions(std::map<std::string, std::string> &map)
556 {
557     if (!hour12.empty()) {
558         map.insert(std::make_pair("hour12", hour12));
559     }
560     if (!weekday.empty()) {
561         map.insert(std::make_pair("weekday", weekday));
562     }
563     if (!era.empty()) {
564         map.insert(std::make_pair("era", era));
565     }
566     if (!year.empty()) {
567         map.insert(std::make_pair("year", year));
568     }
569     if (!month.empty()) {
570         map.insert(std::make_pair("month", month));
571     }
572     if (!day.empty()) {
573         map.insert(std::make_pair("day", day));
574     }
575     if (!hour.empty()) {
576         map.insert(std::make_pair("hour", hour));
577     }
578     if (!minute.empty()) {
579         map.insert(std::make_pair("minute", minute));
580     }
581     if (!second.empty()) {
582         map.insert(std::make_pair("second", second));
583     }
584     if (!dayPeriod.empty()) {
585         map.insert(std::make_pair("dayPeriod", dayPeriod));
586     }
587     if (!localeMatcher.empty()) {
588         map.insert(std::make_pair("localeMatcher", localeMatcher));
589     }
590     if (!formatMatcher.empty()) {
591         map.insert(std::make_pair("formatMatcher", formatMatcher));
592     }
593 }
594 
GetDateStyle() const595 std::string DateTimeFormat::GetDateStyle() const
596 {
597     return dateStyle;
598 }
599 
GetTimeStyle() const600 std::string DateTimeFormat::GetTimeStyle() const
601 {
602     return timeStyle;
603 }
604 
GetHourCycle() const605 std::string DateTimeFormat::GetHourCycle() const
606 {
607     return hourCycle;
608 }
609 
GetTimeZone() const610 std::string DateTimeFormat::GetTimeZone() const
611 {
612     return timeZone;
613 }
614 
GetTimeZoneName() const615 std::string DateTimeFormat::GetTimeZoneName() const
616 {
617     return timeZoneName;
618 }
619 
GetNumberingSystem() const620 std::string DateTimeFormat::GetNumberingSystem() const
621 {
622     return numberingSystem;
623 }
624 
GetHour12() const625 std::string DateTimeFormat::GetHour12() const
626 {
627     return hour12;
628 }
629 
GetWeekday() const630 std::string DateTimeFormat::GetWeekday() const
631 {
632     return weekday;
633 }
634 
GetEra() const635 std::string DateTimeFormat::GetEra() const
636 {
637     return era;
638 }
639 
GetYear() const640 std::string DateTimeFormat::GetYear() const
641 {
642     return year;
643 }
644 
GetMonth() const645 std::string DateTimeFormat::GetMonth() const
646 {
647     return month;
648 }
649 
GetDay() const650 std::string DateTimeFormat::GetDay() const
651 {
652     return day;
653 }
654 
GetHour() const655 std::string DateTimeFormat::GetHour() const
656 {
657     return hour;
658 }
659 
GetMinute() const660 std::string DateTimeFormat::GetMinute() const
661 {
662     return minute;
663 }
664 
GetSecond() const665 std::string DateTimeFormat::GetSecond() const
666 {
667     return second;
668 }
669 
Init()670 bool DateTimeFormat::Init()
671 {
672     SetHwIcuDirectory();
673     return true;
674 }
675 } // namespace I18n
676 } // namespace Global
677 } // namespace OHOS
678