2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
4 // Licensed under the Apache License, Version 2.0 (the License);
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
8 // http://www.apache.org/licenses/LICENSE-2.0
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
18 * @file FLclLocaleData.cpp
19 * @brief This is the implementation file for _LocaleData class.
28 #include <runtime_info.h>
29 #include <unique_ptr.h>
30 #include <FBaseSysLog.h>
31 #include <FSysSettingInfo.h>
32 #include <FLclNumberSymbols.h>
33 #include <FApp_AppInfo.h>
34 #include "FBase_StringConverter.h"
35 #include "FLcl_DateTimeSymbolsImpl.h"
36 #include "FLcl_CalendarImpl.h"
37 #include "FLcl_IcuCalendarImpl.h"
38 #include "FLcl_LocaleData.h"
39 #include "FLcl_LocaleImpl.h"
43 #define LOCALE_DATA_NUM_OF_MILLISEC_IN_HOUR 3600000LL // number of mili second in a hour
44 #define LOCALE_DATA_NUM_OF_MILLISEC_IN_MINUTE 60000LL // number of mili second in a minute
46 using namespace Tizen::Base;
47 using namespace Tizen::Base::Collection;
48 using namespace Tizen::Base::Utility;
50 namespace Tizen { namespace Locales
53 /////////////////////////////////////////////////////////////////////////////////////////////////////
56 // this function is to convert ICU FieldPosition from OSP _FieldPosition
58 _LocaleData::GetIcuFieldPosition(_FieldPosition pos)
60 IcuFieldPosition icuPos(pos.GetField()); // Create IcuFieldPosition with field value in pos
61 icuPos.setBeginIndex(pos.GetBeginIndex()); // Set Beginning index
62 icuPos.setEndIndex(pos.GetEndIndex()); // Set End index
66 U_ICU_NAMESPACE::UnicodeString
67 _LocaleData::GetIcuString(const String& ospStr)
69 IcuUnicodeString icuStr;
71 if (!ospStr.IsEmpty()) // if ospStr is not empty
73 ByteBuffer* pBuff = null;
74 pBuff = StringUtil::StringToUtf8N(ospStr); // Convert unicode value to UTF8
77 icuStr = IcuUnicodeString((const char*) pBuff->GetPointer()); // Create ICU string using UTF8 array
78 icuStr.setCharAt(0, icuStr.charAt(0)); // This is to handle ICU copy on write design
79 delete pBuff; // delete temporary buffer
86 // This function convert ICU string to OSP string
88 _LocaleData::GetOspString(const IcuUnicodeString& icuStr)
90 int len = icuStr.length(); // get length
91 if (len > 0) // if icuStr is not empty
93 wchar_t wstr[len + 1];
94 IcuUnicodeString tmpIcuStr(icuStr);
95 for (int i = 0; i < len ; i++)
98 icuChar = tmpIcuStr.charAt(i);
99 wstr[i] = (wchar_t)icuChar;
107 // This convert OSP string to ICU strings
109 _LocaleData::GetIcuString(const String& ospStr, IcuUnicodeString& icuStr)
111 if (!ospStr.IsEmpty()) // if ospStr is not empty
113 ByteBuffer* pBuff = null;
114 pBuff = StringUtil::StringToUtf8N(ospStr); // Convert unicode value to UTF8
117 icuStr = IcuUnicodeString((const char*) pBuff->GetPointer()); // Create ICU string using UTF8 array
118 icuStr.setCharAt(0, icuStr.charAt(0)); // This is to handle ICU copy on write design
119 delete pBuff; // delete temporary buffer
126 // This function return OSP array list of OSP string from ICU string list
128 _LocaleData::ConvertIcuStringArrayToOspArrayN(const IcuUnicodeString* pIcuStrList, int count)
130 SysTryReturn(NID_LCL, pIcuStrList && count > 0, null, E_INVALID_ARG, "It is invalid argument.");
132 result r = E_SUCCESS;
133 std::unique_ptr< ArrayList> pTempArrayList(new (std::nothrow) ArrayList(SingleObjectDeleter));
134 SysTryReturn(NID_LCL, pTempArrayList, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
135 pTempArrayList->Construct(count);
137 for (int i = 0; i < count; i++)
139 std::unique_ptr< String > pString(new (std::nothrow) String(_LocaleData::GetOspString(pIcuStrList[i])));
140 SysTryReturn(NID_LCL, pString, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
142 if (!pString->IsEmpty())
144 r = pTempArrayList->Add(pString.get()); // Add OSP string to arraylist if it is not empty
145 SysTryReturn(NID_LCL, !IsFailed(r), null, E_SYSTEM, "It is failed to add string [%ls]", pString->GetPointer());
150 SetLastResult(r); // Setting last result value
151 return pTempArrayList.release(); // Return array list
154 // this function convert OSP string array list to ICU string array list
156 _LocaleData::ConvertOspArrayToIcuStringArrayN(const Tizen::Base::Collection::IList* pIcuStrList, int& count)
158 count = 0; // Setting count [Out param] to 0
159 SysTryReturn(NID_LCL, pIcuStrList, null, E_INVALID_ARG, "[%s] Invalid argument is used. pIcuStrList is null.", GetErrorMessage(E_INVALID_ARG));
161 count = pIcuStrList->GetCount();
162 if (count > 0) // if pIcuStrList is not empty
164 IcuUnicodeString* pIcuStrArray = new IcuUnicodeString[count];
165 if (pIcuStrArray) // if allocation is successful
167 IEnumerator* pEnum = pIcuStrList->GetEnumeratorN();
168 if (pEnum) // if pEnum is non null
172 while (pEnum->MoveNext() == E_SUCCESS) // if enum has more value
174 pObj = static_cast< String* >(pEnum->GetCurrent()); // Get object and cast it to String
175 if (pObj) // if String is non null
177 GetIcuString(*pObj, pIcuStrArray[i]); // Convert it to ICU string and set to array
182 delete pEnum; // Delete enumerator
183 return pIcuStrArray; // return ICU Array
185 delete[] pIcuStrArray;
189 return null; // return null in case of failure
194 _LocaleData::GetIcuLocale(const Locale& ospLocale)
197 String language = ospLocale.GetLanguageCodeString();
198 String country = ospLocale.GetCountryCodeString();
199 String variant = ospLocale.GetVariantCodeString();
201 const char* pLangStr = _StringConverter::CopyToCharArrayN(language);
202 const char* pCountryStr = _StringConverter::CopyToCharArrayN(country);
203 const char* pVariantStr = null;
205 if (!variant.IsEmpty())
207 pVariantStr = _StringConverter::CopyToCharArrayN(variant);
210 IcuLocale icuLocale = IcuLocale(pLangStr, pCountryStr, pVariantStr);
213 delete[] pCountryStr;
214 delete[] pVariantStr;
216 if (icuLocale.isBogus())
218 SetLastResult(E_SYSTEM);
226 _LocaleData::GetIcuLocale(void)
232 _LocaleData::IsLocaleSupported(void)
234 return !__icuLocale.isBogus();
238 _LocaleData::SetLocale(const Locale& ospLocale)
240 if (_LocaleImpl::IsSupported(ospLocale))
242 __icuLocale = GetIcuLocale(ospLocale);
246 __icuLocale.setToBogus();
247 return (Tizen::App::_AppInfo::GetApiVersion() == _API_VERSION_2_0 && Tizen::App::_AppInfo::IsOspCompat()) ? E_UNSUPPORTED_OPERATION : E_INVALID_ARG;
251 _LocaleData::GetNumberSymbols(const Locale& locale, String symbols[])
253 UErrorCode status = U_ZERO_ERROR;
257 SysTryReturnResult(NID_LCL, IsLocaleSupported(), E_SYSTEM, "A System error has been occurred. Locale is not supported");
259 IcuDecimalFormatSymbols sym(__icuLocale, status);
260 SysTryReturnResult(NID_LCL, U_SUCCESS(status), E_SYSTEM, "A System error has been occurred. Unable to get ICU Decimal Format Symbols");
262 symbols[NUMBER_SYMBOL_DECIMAL_SEPARATOR] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kDecimalSeparatorSymbol));
263 symbols[NUMBER_SYMBOL_GROUPING_SEPARATOR] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kGroupingSeparatorSymbol));
264 symbols[NUMBER_SYMBOL_PATTERN_SEPARATOR] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kPatternSeparatorSymbol));
265 symbols[NUMBER_SYMBOL_PERCENT] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kPercentSymbol));
266 symbols[NUMBER_SYMBOL_ZERO_DIGIT] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kZeroDigitSymbol));
267 symbols[NUMBER_SYMBOL_DIGIT] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kDigitSymbol));
268 symbols[NUMBER_SYMBOL_CURRENCY] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kCurrencySymbol));
269 symbols[NUMBER_SYMBOL_INTL_CURRENCY] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kIntlCurrencySymbol));
270 symbols[NUMBER_SYMBOL_MONETARY_SEPARATOR] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kMonetarySeparatorSymbol));
271 symbols[NUMBER_SYMBOL_PER_MILL] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kPerMillSymbol));
272 symbols[NUMBER_SYMBOL_EXPONENTIAL] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kExponentialSymbol));
273 symbols[NUMBER_SYMBOL_PLUS_SIGN] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kPlusSignSymbol));
274 symbols[NUMBER_SYMBOL_MINUS_SIGN] = _LocaleData::GetOspString(sym.getSymbol(IcuDecimalFormatSymbols::kMinusSignSymbol));
280 _LocaleData::SetNumberFormatter(const Locale& locale, NumberFormatterStyle style)
282 if (__pIcuNumberFormatter)
284 delete __pIcuNumberFormatter;
285 __pIcuNumberFormatter = null;
288 IcuNumberFormat* pNumFmt = null;
289 UErrorCode ec = U_ZERO_ERROR;
290 result r = SetLocale(locale);
296 case NUM_FORMATTER_STYLE_NUMBER:
298 pNumFmt = IcuNumberFormat::createInstance(__icuLocale, ec);
302 case NUM_FORMATTER_STYLE_CURRENCY:
304 pNumFmt = IcuNumberFormat::createCurrencyInstance(__icuLocale, ec);
308 case NUM_FORMATTER_STYLE_PERCENT:
310 pNumFmt = IcuNumberFormat::createPercentInstance(__icuLocale, ec);
316 r = E_UNSUPPORTED_OPERATION;
328 if (pNumFmt && (pNumFmt->getDynamicClassID() == IcuDecimalFormat::getStaticClassID()))
330 __pIcuNumberFormatter = dynamic_cast< IcuDecimalFormat* >(pNumFmt);
331 if (__pIcuNumberFormatter)
339 return E_UNSUPPORTED_OPERATION;
343 _LocaleData::FormatNumber(long number, _FieldPosition& pos, Tizen::Base::String& str)
347 if (__pIcuNumberFormatter)
349 IcuUnicodeString icuStr;
350 IcuFieldPosition icuPos = GetIcuFieldPosition(pos);
351 icuStr = __pIcuNumberFormatter->format(static_cast< int32_t >(number), icuStr, icuPos);
353 str = _LocaleData::GetOspString(icuStr);
361 _LocaleData::FormatNumber(double number, _FieldPosition& pos, Tizen::Base::String& str)
365 if (__pIcuNumberFormatter)
367 IcuUnicodeString icuStr;
368 IcuFieldPosition icuPos = GetIcuFieldPosition(pos);
369 icuStr = __pIcuNumberFormatter->format(number, icuStr, icuPos);
371 str = _LocaleData::GetOspString(icuStr);
379 _LocaleData::ApplyNumberPattern(const Tizen::Base::String& pattern, bool localized)
381 if (__pIcuNumberFormatter)
383 IcuUnicodeString icuPattern;
384 icuPattern = __pIcuNumberFormatter->toPattern(icuPattern);
386 UErrorCode ec = U_ZERO_ERROR;
387 IcuUParseError parseError = {0};
388 IcuUnicodeString icuNewPatter;
389 GetIcuString(pattern, icuNewPatter);
393 __pIcuNumberFormatter->applyLocalizedPattern(icuNewPatter, parseError, ec);
397 __pIcuNumberFormatter->applyPattern(icuNewPatter, parseError, ec);
406 SysLog(NID_LCL, "Error [%d -> %s] in setting pattern to %ls at %d:%d",
407 ec, u_errorName(ec), pattern.GetPointer(), parseError.line, parseError.offset);
409 __pIcuNumberFormatter->applyPattern(icuPattern, ec);
413 return E_INVALID_ARG;
417 _LocaleData::GetNumberFormatterStringAttributes(NumberFormatterAttributes attrName)
419 IcuUnicodeString icuRetValue;
421 if (__pIcuNumberFormatter)
425 case NUM_FORMATTER_FIELD_CURRENCY:
427 icuRetValue = __pIcuNumberFormatter->getCurrency();
431 case NUM_FORMATTER_FIELD_POSITIVE_PREFIX:
433 icuRetValue = __pIcuNumberFormatter->getPositivePrefix(icuRetValue);
437 case NUM_FORMATTER_FIELD_NEGATIVE_PREFIX:
439 icuRetValue = __pIcuNumberFormatter->getNegativePrefix(icuRetValue);
443 case NUM_FORMATTER_FIELD_POSITIVE_SUFFIX:
445 icuRetValue = __pIcuNumberFormatter->getPositiveSuffix(icuRetValue);
449 case NUM_FORMATTER_FIELD_NEGATIVE_SUFFIX:
451 icuRetValue = __pIcuNumberFormatter->getNegativeSuffix(icuRetValue);
455 case NUM_FORMATTER_FIELD_PATTERN:
457 icuRetValue = __pIcuNumberFormatter->toPattern(icuRetValue);
461 case NUM_FORMATTER_FIELD_LOCALIZED_PATTERN:
463 icuRetValue = __pIcuNumberFormatter->toLocalizedPattern(icuRetValue);
473 return _LocaleData::GetOspString(icuRetValue);
476 return Tizen::Base::String("");
480 _LocaleData::SetNumberFormatterAttributes(const String& newValue, NumberFormatterAttributes attrName)
482 if (__pIcuNumberFormatter)
484 IcuUnicodeString icuNewValue;
485 GetIcuString(newValue, icuNewValue);
489 case NUM_FORMATTER_FIELD_CURRENCY:
491 __pIcuNumberFormatter->setCurrency(icuNewValue.getTerminatedBuffer());
495 case NUM_FORMATTER_FIELD_POSITIVE_PREFIX:
497 __pIcuNumberFormatter->setPositivePrefix(icuNewValue);
501 case NUM_FORMATTER_FIELD_NEGATIVE_PREFIX:
503 __pIcuNumberFormatter->setNegativePrefix(icuNewValue);
507 case NUM_FORMATTER_FIELD_POSITIVE_SUFFIX:
509 __pIcuNumberFormatter->setPositiveSuffix(icuNewValue);
513 case NUM_FORMATTER_FIELD_NEGATIVE_SUFFIX:
515 __pIcuNumberFormatter->setNegativeSuffix(icuNewValue);
528 _LocaleData::GetNumberFormatterIntAttributes(NumberFormatterAttributes attrName)
531 if (__pIcuNumberFormatter)
535 case NUM_FORMATTER_FIELD_MAX_INTEGER_DIGITS:
537 res = __pIcuNumberFormatter->getMaximumIntegerDigits();
541 case NUM_FORMATTER_FIELD_MIN_INTEGER_DIGITS:
543 res = __pIcuNumberFormatter->getMinimumIntegerDigits();
547 case NUM_FORMATTER_FIELD_MAX_FRACTION_DIGITS:
549 res = __pIcuNumberFormatter->getMaximumFractionDigits();
553 case NUM_FORMATTER_FIELD_MIN_FRACTION_DIGITS:
555 res = __pIcuNumberFormatter->getMinimumFractionDigits();
559 case NUM_FORMATTER_FIELD_MIN_EXPONENT_DIGITS:
561 res = __pIcuNumberFormatter->getMinimumExponentDigits();
565 case NUM_FORMATTER_FIELD_MULTIPLIER:
567 res = __pIcuNumberFormatter->getMultiplier();
571 case NUM_FORMATTER_FIELD_GROUPING_SIZE:
573 res = __pIcuNumberFormatter->getGroupingSize();
589 _LocaleData::SetNumberFormatterAttributes(const int newValue, NumberFormatterAttributes attrName)
591 if (__pIcuNumberFormatter)
595 case NUM_FORMATTER_FIELD_MAX_INTEGER_DIGITS:
597 __pIcuNumberFormatter->setMaximumIntegerDigits(newValue);
601 case NUM_FORMATTER_FIELD_MIN_INTEGER_DIGITS:
603 __pIcuNumberFormatter->setMinimumIntegerDigits(newValue);
607 case NUM_FORMATTER_FIELD_MAX_FRACTION_DIGITS:
609 __pIcuNumberFormatter->setMaximumFractionDigits(newValue);
613 case NUM_FORMATTER_FIELD_MIN_FRACTION_DIGITS:
615 __pIcuNumberFormatter->setMinimumFractionDigits(newValue);
619 case NUM_FORMATTER_FIELD_MIN_EXPONENT_DIGITS:
621 __pIcuNumberFormatter->setMinimumExponentDigits(newValue);
625 case NUM_FORMATTER_FIELD_MULTIPLIER:
627 __pIcuNumberFormatter->setMultiplier(newValue);
631 case NUM_FORMATTER_FIELD_GROUPING_SIZE:
633 __pIcuNumberFormatter->setGroupingSize(newValue);
646 _LocaleData::GetNumberFormatterBoolAttributes(NumberFormatterAttributes attrName)
649 if (__pIcuNumberFormatter)
653 case NUM_FORMATTER_FIELD_IS_GROUPING_USED:
655 res = __pIcuNumberFormatter->isGroupingUsed();
659 case NUM_FORMATTER_FIELD_IS_DECIMAL_SEPARATOR_ALWAYS_SHOWN:
661 res = __pIcuNumberFormatter->isDecimalSeparatorAlwaysShown();
665 case NUM_FORMATTER_FIELD_IS_POSITIVE_SIGN_ALWAYS_SHOWN:
667 IcuUnicodeString ps("+");
669 pp = __pIcuNumberFormatter->getPositivePrefix(pp);
687 _LocaleData::SetNumberFormatterAttributes(const bool newValue, NumberFormatterAttributes attrName)
689 if (__pIcuNumberFormatter)
693 case NUM_FORMATTER_FIELD_IS_GROUPING_USED:
695 __pIcuNumberFormatter->setGroupingUsed(newValue);
699 case NUM_FORMATTER_FIELD_IS_DECIMAL_SEPARATOR_ALWAYS_SHOWN:
701 __pIcuNumberFormatter->setDecimalSeparatorAlwaysShown(newValue);
705 case NUM_FORMATTER_FIELD_IS_POSITIVE_SIGN_ALWAYS_SHOWN:
707 IcuUnicodeString ps("+");
709 pp = __pIcuNumberFormatter->getPositivePrefix(pp);
713 __pIcuNumberFormatter->setPositivePrefix(ps);
719 __pIcuNumberFormatter->setPositivePrefix("");
734 _LocaleData::SetDateFormatSymbols(const Locale& locale)
736 if (__pIcuDateFormatSymbols)
738 delete __pIcuDateFormatSymbols;
739 __pIcuDateFormatSymbols = null;
742 UErrorCode ec = U_ZERO_ERROR;
743 result r = SetLocale(locale);
747 __pIcuDateFormatSymbols = new IcuDateFormatSymbols(__icuLocale, ec);
749 if (__pIcuDateFormatSymbols && U_SUCCESS(ec))
755 delete __pIcuDateFormatSymbols;
756 __pIcuDateFormatSymbols = null;
762 _LocaleData::GetDateFormatSymbolAttrArrayN(DateFormatSymbolsAttributes attrName)
764 if (__pIcuDateFormatSymbols)
768 const IcuUnicodeString* pIcuList = null;
772 case DATE_FORMAT_SYM_ERA_LIST:
774 pIcuList = __pIcuDateFormatSymbols->getEras(count);
778 case DATE_FORMAT_SYM_MONTH_LIST:
780 pIcuList = __pIcuDateFormatSymbols->getMonths(count);
784 case DATE_FORMAT_SYM_SHORT_MONTH_LIST:
786 pIcuList = __pIcuDateFormatSymbols->getShortMonths(count);
790 case DATE_FORMAT_SYM_WEEKDAY_LIST:
792 pIcuList = __pIcuDateFormatSymbols->getWeekdays(count);
796 case DATE_FORMAT_SYM_SHORT_WEEKDAY_LIST:
798 pIcuList = __pIcuDateFormatSymbols->getShortWeekdays(count);
802 case DATE_FORMAT_SYM_AM_PM_LIST:
804 pIcuList = __pIcuDateFormatSymbols->getAmPmStrings(count);
810 SetLastResult(E_UNSUPPORTED_OPERATION);
817 return ConvertIcuStringArrayToOspArrayN(pIcuList, count);
821 SetLastResult(E_INVALID_STATE);
827 _LocaleData::GetIcuDate(DateTime date)
829 DateTime icuBaseTime;
830 icuBaseTime.SetValue(1970, 1, 1);
831 DateTime ospBaseTime = DateTime::GetMinValue();
833 result r = icuBaseTime.Subtract(ospBaseTime.GetTime());
836 SysLogException(NID_LCL, r, "[%s] Propagated.", GetErrorMessage(r));
839 TimeSpan tsIcu = icuBaseTime.GetTime();
840 TimeSpan tsOsp = date.GetTime();
841 TimeSpan diff = tsOsp - tsIcu;
843 IcuUDate icuDate = diff.GetTicks();
848 _LocaleData::SetDateTimeFormatter(DateTimeStyle dateStyle, DateTimeStyle timeStyle, const Locale& locale)
850 IcuDateFormat* pIcuDateFormat = null;
852 result r = SetLocale(locale);
853 SysTryReturnResult(NID_LCL, !IsFailed(r), E_INVALID_ARG, "Locale setting failed.");
855 U_ICU_NAMESPACE::DateFormat::EStyle icuDateStyle = (U_ICU_NAMESPACE::DateFormat::EStyle) dateStyle;
856 U_ICU_NAMESPACE::DateFormat::EStyle icuTimeStyle = (U_ICU_NAMESPACE::DateFormat::EStyle) timeStyle;
858 if (dateStyle == DATE_TIME_STYLE_NONE)
860 if (timeStyle != DATE_TIME_STYLE_NONE)
862 pIcuDateFormat = IcuDateFormat::createTimeInstance(icuTimeStyle, __icuLocale);
867 if (timeStyle == DATE_TIME_STYLE_NONE)
869 pIcuDateFormat = IcuDateFormat::createDateInstance(icuDateStyle, __icuLocale);
873 pIcuDateFormat = IcuDateFormat::createDateTimeInstance(icuDateStyle, icuTimeStyle, __icuLocale);
879 if (__pIcuDateFormat)
881 delete __pIcuDateFormat;
882 __pIcuDateFormat = null;
884 __pIcuDateFormat = dynamic_cast< IcuSimpleDateFormat* >(pIcuDateFormat);
886 if (__pIcuDateFormat)
888 if (__pIcuDateFormatSymbols)
890 delete __pIcuDateFormatSymbols;
891 __pIcuDateFormatSymbols = null;
894 const IcuDateFormatSymbols* pDateTimeFormatSym = __pIcuDateFormat->getDateFormatSymbols();
896 if (pDateTimeFormatSym)
898 __pIcuDateFormatSymbols = new IcuDateFormatSymbols(*pDateTimeFormatSym);
905 delete pIcuDateFormat;
906 return E_INVALID_ARG;
910 _LocaleData::SetStartTimeRule(IcuSimpleTimeZone& zone, const TimeRule* pOspTimeRule)
914 UErrorCode status = U_ZERO_ERROR;
915 IcuDateTimeRule::TimeRuleType icuTimeRuleType;
917 DstRuleMode ospRuleMode = static_cast< DstRuleMode >(pOspTimeRule->GetRuleMode());
918 Tizen::System::TimeMode ospTimeMode = pOspTimeRule->GetTimeMode();
922 case Tizen::System::UTC_TIME:
924 icuTimeRuleType = IcuDateTimeRule::UTC_TIME;
928 case Tizen::System::STANDARD_TIME:
930 icuTimeRuleType = IcuDateTimeRule::STANDARD_TIME;
934 case Tizen::System::WALL_TIME:
937 icuTimeRuleType = IcuDateTimeRule::WALL_TIME;
942 int time = ((pOspTimeRule->GetHour() * 60) + pOspTimeRule->GetMinute()) * 60 * 1000;
949 pOspTimeRule->GetMonth(),
950 pOspTimeRule->GetDay(),
957 case DAY_OF_WEEK_IN_MONTH:
960 pOspTimeRule->GetMonth(),
961 pOspTimeRule->GetWeek(),
962 pOspTimeRule->GetDayOfWeek(),
969 case AFTER_THE_SPECIFIED_DAY:
972 pOspTimeRule->GetMonth(),
973 pOspTimeRule->GetDay(),
974 pOspTimeRule->GetDayOfWeek(),
981 case BEFORE_THE_SPECIFIED_DAY:
984 pOspTimeRule->GetMonth(),
985 pOspTimeRule->GetDay(),
986 -pOspTimeRule->GetDayOfWeek(),
993 case BACKWARD_FROM_END_OF_MONTH:
996 pOspTimeRule->GetMonth(),
997 pOspTimeRule->GetWeek() * -1,
1005 return U_SUCCESS(status) ? E_SUCCESS : E_SYSTEM;
1007 return E_INVALID_ARG;
1011 _LocaleData::SetEndTimeRule(IcuSimpleTimeZone& zone, const TimeRule* pOspTimeRule)
1015 UErrorCode status = U_ZERO_ERROR;
1016 IcuDateTimeRule::TimeRuleType icuTimeRuleType;
1018 DstRuleMode ospRuleMode = static_cast< DstRuleMode >(pOspTimeRule->GetRuleMode());
1019 Tizen::System::TimeMode ospTimeMode = pOspTimeRule->GetTimeMode();
1021 switch (ospTimeMode)
1023 case Tizen::System::UTC_TIME:
1025 icuTimeRuleType = IcuDateTimeRule::UTC_TIME;
1029 case Tizen::System::STANDARD_TIME:
1031 icuTimeRuleType = IcuDateTimeRule::STANDARD_TIME;
1035 case Tizen::System::WALL_TIME:
1038 icuTimeRuleType = IcuDateTimeRule::WALL_TIME;
1043 int time = ((pOspTimeRule->GetHour() * 60) + pOspTimeRule->GetMinute()) * 60 * 1000;
1045 switch (ospRuleMode)
1050 pOspTimeRule->GetMonth(),
1051 pOspTimeRule->GetDay(),
1058 case DAY_OF_WEEK_IN_MONTH:
1061 pOspTimeRule->GetMonth(),
1062 pOspTimeRule->GetWeek(),
1063 pOspTimeRule->GetDayOfWeek(),
1070 case AFTER_THE_SPECIFIED_DAY:
1073 pOspTimeRule->GetMonth(),
1074 pOspTimeRule->GetDay(),
1075 pOspTimeRule->GetDayOfWeek(),
1082 case BEFORE_THE_SPECIFIED_DAY:
1085 pOspTimeRule->GetMonth(),
1086 pOspTimeRule->GetDay(),
1087 -pOspTimeRule->GetDayOfWeek(),
1094 case BACKWARD_FROM_END_OF_MONTH:
1097 pOspTimeRule->GetMonth(),
1098 pOspTimeRule->GetWeek() * -1,
1106 return U_SUCCESS(status) ? E_SUCCESS : E_SYSTEM;
1108 return E_INVALID_ARG;
1112 _LocaleData::FormatDateTime(const DateTime& date, String& str)
1114 std::auto_ptr <Calendar> pCal(Calendar::CreateInstanceN());
1115 SysTryReturnResult(NID_LCL, pCal.get(), E_OUT_OF_MEMORY, "Memory allocation failed");
1117 result r = pCal->SetTime(date);
1118 SysTryReturn(NID_LCL, r == E_SUCCESS, r, r, "[%s] Unable to set date time in default calendar");
1120 r = pCal->Clear(TIME_FIELD_MILLISECOND);
1121 SysTryReturn(NID_LCL, r == E_SUCCESS, r, r, "[%s] Unable to set date time in default calendar");
1123 return FormatDateTime(*pCal, str);
1127 _LocaleData::FormatDateTime(const Calendar& calendar, Tizen::Base::String& str)
1129 SysTryReturnResult(NID_LCL, __pIcuDateFormat, E_INVALID_STATE, "This instance is not constructed");
1132 const _IcuCalendarImpl* _pIcuCalendarImpl = _CalendarImpl::GetImpl(calendar);
1133 if (_pIcuCalendarImpl)
1135 IcuCalendar* pIcuCal = _pIcuCalendarImpl->GetIcuCalendarCloneN();
1138 IcuFieldPosition icuFp;
1139 IcuUnicodeString icuStr;
1141 GetIcuString(str,icuStr);
1142 icuStr = __pIcuDateFormat->format(*pIcuCal, icuStr, icuFp);
1143 str = _LocaleData::GetOspString(icuStr);
1146 return GetLastResult();
1154 _LocaleData::GetDateTimePattern()
1156 SysTryReturn(NID_LCL, __pIcuDateFormat, String(""), E_INVALID_STATE, "This instance is not constructed");
1157 IcuUnicodeString icuPattern;
1159 icuPattern = __pIcuDateFormat->toPattern(icuPattern);
1160 return _LocaleData::GetOspString(icuPattern);
1164 _LocaleData::SetDateTimePattern(const String& pattern)
1166 SysTryReturnResult(NID_LCL, __pIcuDateFormat, E_INVALID_STATE, "This instance is not constructed");
1167 IcuUnicodeString icuStr;
1169 GetIcuString(pattern, icuStr);
1171 __pIcuDateFormat->applyPattern(icuStr);
1176 _LocaleData::GetDateTimeSymbolsN(DateTimeSymbols* pDateTimeSymbols)
1178 SysTryReturn(NID_LCL, __pIcuDateFormatSymbols, null, E_INVALID_STATE, "[E_INVALID_STATE] This instance is not constructed");
1179 SysTryReturn(NID_LCL, pDateTimeSymbols, null, E_INVALID_ARG, "[%s] Invalid argument is used. pDateTimeSymbols is null.", GetErrorMessage(E_INVALID_ARG));
1181 _DateTimeSymbolsImpl* pDateTimeSymbolsImpl = _DateTimeSymbolsImpl::GetDateTimeSymbolsImpl(pDateTimeSymbols);
1183 if (pDateTimeSymbolsImpl)
1185 pDateTimeSymbolsImpl->ReleaseAll();
1187 pDateTimeSymbolsImpl->__pErasList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_ERA_LIST);
1188 pDateTimeSymbolsImpl->__pMonthsList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_MONTH_LIST);
1189 pDateTimeSymbolsImpl->__pShortMonthsList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_SHORT_MONTH_LIST);
1190 pDateTimeSymbolsImpl->__pWeekdaysList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_WEEKDAY_LIST);
1191 pDateTimeSymbolsImpl->__pShortWeekdaysList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_SHORT_WEEKDAY_LIST);
1192 pDateTimeSymbolsImpl->__pAmPmList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_AM_PM_LIST);
1194 return pDateTimeSymbols;
1200 // This function convert and set ICU DateTime symbols from OSP DateTimeSymbols
1202 _LocaleData::SetDateTimeSymbols(const DateTimeSymbols& newValue)
1204 UErrorCode ec = U_ZERO_ERROR;
1206 if (!__pIcuDateFormatSymbols)
1208 __pIcuDateFormatSymbols = new IcuDateFormatSymbols(ec);
1211 IcuUnicodeString* pIcuArray = null;
1214 if (U_SUCCESS(ec) && __pIcuDateFormatSymbols != null)
1216 pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetEras(), count);
1217 __pIcuDateFormatSymbols->setEras(pIcuArray, count);
1220 pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetMonths(), count);
1221 __pIcuDateFormatSymbols->setMonths(pIcuArray, count);
1224 pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetShortMonths(), count);
1225 __pIcuDateFormatSymbols->setShortMonths(pIcuArray, count);
1228 pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetWeekdays(), count);
1229 __pIcuDateFormatSymbols->setWeekdays(pIcuArray, count);
1232 pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetShortWeekdays(), count);
1233 __pIcuDateFormatSymbols->setShortWeekdays(pIcuArray, count);
1236 pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetAmPm(), count);
1237 __pIcuDateFormatSymbols->setAmPmStrings(pIcuArray, count);
1240 // From ICU Docs: SimpleDateFormat no longer use the zone strings stored in a DateFormatSymbols. Therefore, the time zone strings
1241 // set by this method have no effects in an instance of SimpleDateFormat for formatting time zones.
1242 // __pIcuDateFormatSymbols->setZoneStrings();
1244 __pIcuDateFormat->setDateFormatSymbols(*__pIcuDateFormatSymbols);
1248 return E_UNSUPPORTED_OPERATION;
1252 _LocaleData::SetGregorianWeekCountData(const Locale& ospLocale, DayOfWeek& firstDayOfWeek, short& minDaysInFirstWeek)
1254 UErrorCode success = U_ZERO_ERROR;
1255 IcuLocale icuLocale;
1257 icuLocale = GetIcuLocale(ospLocale);
1258 result r = GetLastResult();
1259 SysAssert(r == E_SUCCESS);
1261 GregorianCalendar gc(icuLocale, success);
1262 SysAssert(U_SUCCESS(success));
1264 firstDayOfWeek = (DayOfWeek) gc.getFirstDayOfWeek(); // Set __firstDayOfWeek from ICU data
1265 minDaysInFirstWeek = 1; // To align with 2.0 version
1266 // minDaysInFirstWeek = (short) gc.getMinimalDaysInFirstWeek(); // Set __minDaysInFirstWeek from ICU data
1269 _LocaleData::_LocaleData(void)
1271 , // default ICU locale
1272 __pIcuNumberFormatter(null)
1273 , __pIcuDateFormatSymbols(null)
1274 , __pIcuDateFormat(null)
1279 _LocaleData::~_LocaleData(void)
1281 if (__pIcuNumberFormatter) // Delete __pIcuNumberFormatter and set to null
1283 delete __pIcuNumberFormatter;
1284 __pIcuNumberFormatter = null;
1287 if (__pIcuDateFormatSymbols) // Delete __pIcuDateFormatSymbols and set to null
1289 delete __pIcuDateFormatSymbols;
1290 __pIcuDateFormatSymbols = null;
1293 if (__pIcuDateFormat) // Delete __pIcuDateFormat and set to null
1295 delete __pIcuDateFormat;
1296 __pIcuDateFormat = null;
1302 }; // Tizen::Locales