#include <FBaseSysLog.h>
#include <FApp_AppInfo.h>
-
+#include <FBaseColArrayList.h>
+#include <FBaseColAllElementsDeleter.h>
#include "FLcl_LocaleData.h"
#include "FLcl_LocaleImpl.h"
#include "FLcl_CurrencyImpl.h"
// Includes
#include <unique_ptr.h>
+#include <unicode/dtfmtsym.h>
+#include <unicode/smpdtfmt.h>
+#include <unicode/calendar.h>
+
#include <FBaseSysLog.h>
#include <FApp_AppInfo.h>
#include <FLclDateTimeFormatter.h>
#include "FLcl_DateTimeFormatterImpl.h"
#include "FLcl_LocaleData.h"
#include "FLcl_LocaleManagerImpl.h"
+#include "FLcl_CalendarImpl.h"
+#include "FLcl_IcuCalendarImpl.h"
+#include "FLcl_DateTimeSymbolsImpl.h"
using namespace Tizen::Base;
using namespace Tizen::Base::Collection;
{
_DateTimeFormatterImpl::_DateTimeFormatterImpl(void)
- : __pLocaleData(null)
- , __pSymbols(null)
+ : __pSymbols(null)
+ , __pIcuDateFormatter(null)
+ , __pLocale(null)
{
}
_DateTimeFormatterImpl::~_DateTimeFormatterImpl(void)
{
- delete __pLocaleData;
delete __pSymbols;
+ delete __pIcuDateFormatter;
+ delete __pLocale;
}
// The DateTimeFormatter always use System Locale if not provided by the user.
{
result r = (Tizen::App::_AppInfo::GetApiVersion() == _API_VERSION_2_0 && Tizen::App::_AppInfo::IsOspCompat()) ? E_UNSUPPORTED_OPERATION : E_INVALID_ARG;
+ SysTryReturn(NID_LCL, locale.GetLanguageCode() != LANGUAGE_INVALID && locale.GetCountryCode() != COUNTRY_INVALID, null, r, "It is the invalid locale.");
SysTryReturn(NID_LCL, ValidateDateTimeStyle(dateStyle), null, r, "[%s] Invalid argument is used. dateStyle is invalid", GetErrorMessage(r));
SysTryReturn(NID_LCL, ValidateDateTimeStyle(timeStyle), null, r, "[%s] Invalid argument is used. timeStyle is invalid", GetErrorMessage(r));
ClearLastResult();
- // Create a DateTimeFormatter of the desired style.
std::unique_ptr<DateTimeFormatter> pDateTimeFormatter(new (std::nothrow) DateTimeFormatter());
SysTryReturn(NID_LCL, pDateTimeFormatter, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
std::unique_ptr<_DateTimeFormatterImpl> pDateTimeFormatterImpl(new (std::nothrow) _DateTimeFormatterImpl);
SysTryReturn(NID_LCL,pDateTimeFormatterImpl, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
- std::unique_ptr<_LocaleData> pLocaleData(new (std::nothrow) _LocaleData);
- SysTryReturn(NID_LCL, pLocaleData, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
+ std::unique_ptr< U_ICU_NAMESPACE::SimpleDateFormat> pIcuDateFormatter(pDateTimeFormatterImpl->GetIcuDateFormatterN(locale, dateStyle, timeStyle));
+ SysTryReturn(NID_LCL, pIcuDateFormatter, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ pDateTimeFormatterImpl->__pLocale = new (std::nothrow) Locale(locale);
+ SysTryReturn(NID_LCL, pDateTimeFormatterImpl->__pLocale, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
+ pDateTimeFormatterImpl->__pIcuDateFormatter = pIcuDateFormatter.release();
+ pDateTimeFormatter->__pDateTimeFormatterImpl = pDateTimeFormatterImpl.release();
+ return pDateTimeFormatter.release(); // Here as LastResult is already cleared, no need to set it to E_SUCCESS
+}
+
+U_ICU_NAMESPACE::SimpleDateFormat*
+_DateTimeFormatterImpl::GetIcuDateFormatterN(const Locale& locale, DateTimeStyle dateStyle, DateTimeStyle timeStyle)
+{
+ SysTryReturn(NID_LCL, dateStyle != DATE_TIME_STYLE_NONE || timeStyle != DATE_TIME_STYLE_NONE, null, E_INVALID_ARG, "It is an invalid argument.");
- // This create and set ICU DateFormatter in _Locale data object for future use
- r = pLocaleData->SetDateTimeFormatter(dateStyle, timeStyle, locale);
- SysTryReturn(NID_LCL, !IsFailed(r), null, r, "[%s]",GetErrorMessage(r));
+ U_ICU_NAMESPACE::DateFormat* pIcuDateFormat = null;
+ U_ICU_NAMESPACE::DateFormat::EStyle icuDateStyle = (U_ICU_NAMESPACE::DateFormat::EStyle) dateStyle;
+ U_ICU_NAMESPACE::DateFormat::EStyle icuTimeStyle = (U_ICU_NAMESPACE::DateFormat::EStyle) timeStyle;
+ U_ICU_NAMESPACE::Locale icuLocale = _LocaleData::GetIcuLocale(locale);
- // Create DateTimeSymbols and construct using locale
- pDateTimeFormatterImpl->__pSymbols = new (std::nothrow) DateTimeSymbols;
- if (pDateTimeFormatterImpl->__pSymbols)
+ if (dateStyle != DATE_TIME_STYLE_NONE && timeStyle != DATE_TIME_STYLE_NONE)
{
- pDateTimeFormatterImpl->__pSymbols->Construct(locale);
+ pIcuDateFormat = U_ICU_NAMESPACE::DateFormat::createDateTimeInstance(icuDateStyle, icuTimeStyle, icuLocale);
+ }
+ else if (dateStyle != DATE_TIME_STYLE_NONE && timeStyle == DATE_TIME_STYLE_NONE)
+ {
+ pIcuDateFormat = U_ICU_NAMESPACE::DateFormat::createDateInstance(icuDateStyle, icuLocale);
+ }
+ else if (dateStyle == DATE_TIME_STYLE_NONE && timeStyle != DATE_TIME_STYLE_NONE)
+ {
+ pIcuDateFormat = U_ICU_NAMESPACE::DateFormat::createTimeInstance(icuTimeStyle, icuLocale);
}
- pDateTimeFormatter->__pDateTimeFormatterImpl = pDateTimeFormatterImpl.release();
- pDateTimeFormatter->__pDateTimeFormatterImpl->__pLocaleData = pLocaleData.release();
- return pDateTimeFormatter.release(); // Here as LastResult is already cleared, no need to set it to E_SUCCESS
+ return dynamic_cast< U_ICU_NAMESPACE::SimpleDateFormat* >(pIcuDateFormat);
}
+
// This function will not have TimeZone informations and always print time zone as GMT+00:00
result
_DateTimeFormatterImpl::Format(const DateTime& date, String& strBuf) const
{
- SysAssertf(__pLocaleData != null, "Not yet constructed! Construct() should be called before use.");
- return __pLocaleData->FormatDateTime(date, strBuf); // Format date using ICU date formatter
+ SysAssertf(__pIcuDateFormatter != null, "Not yet constructed! Construct() should be called before use.");
+
+ std::unique_ptr< Calendar > pCal(Calendar::CreateInstanceN());
+ SysTryReturnResult(NID_LCL, pCal, E_OUT_OF_MEMORY, "Memory allocation failed");
+
+ result r = pCal->SetTime(date);
+ SysTryReturn(NID_LCL, r == E_SUCCESS, r, r, "[%s] Unable to set date time in default calendar", GetErrorMessage(r));
+
+ r = pCal->Clear(TIME_FIELD_MILLISECOND);
+ SysTryReturn(NID_LCL, r == E_SUCCESS, r, r, "[%s] Unable to set date time in default calendar", GetErrorMessage(r));
+
+ return Format(*(pCal.get()), strBuf);
}
result
_DateTimeFormatterImpl::Format(const Calendar& calendar, String& strBuf) const
{
- SysAssertf(__pLocaleData != null, "Not yet constructed! Construct() should be called before use.");
- return __pLocaleData->FormatDateTime(calendar, strBuf); // Format date using ICU date formatter
+ SysAssertf(__pIcuDateFormatter != null, "Not yet constructed! Construct() should be called before use.");
+
+ const _IcuCalendarImpl* pIcuCalendarImpl = _CalendarImpl::GetImpl(calendar);
+ SysTryReturnResult(NID_LCL, pIcuCalendarImpl, E_SYSTEM, "It is failed to get icu calendar.");
+
+ IcuCalendar* pIcuCal = pIcuCalendarImpl->GetIcuCalendarCloneN();
+ SysTryReturnResult(NID_LCL, pIcuCal, E_SYSTEM, "It is failed to get icu calendar.");
+
+ IcuFieldPosition icuFp;
+ IcuUnicodeString icuStr;
+
+ _LocaleData::GetIcuString(strBuf,icuStr);
+ icuStr = __pIcuDateFormatter->format(*pIcuCal, icuStr, icuFp);
+ strBuf = _LocaleData::GetOspString(icuStr);
+ delete pIcuCal;
+
+ return E_SUCCESS;
}
-// This function sets pattern used by DateTimeFormatter for formatting date.
-// Please check http://icu-project.org/apiref/icu4c/classSimpleDateFormat.html for possible letter and
-// their meaning in patter string.
result
_DateTimeFormatterImpl::ApplyPattern(const String& pattern)
{
- SysAssertf(__pLocaleData != null, "Not yet constructed! Construct() should be called before use.");
- return __pLocaleData->SetDateTimePattern(pattern); // Set pattern to ICU date formatter
+ SysAssertf(__pIcuDateFormatter != null, "Not yet constructed! Construct() should be called before use.");
+ U_ICU_NAMESPACE::UnicodeString icuStr;
+ _LocaleData::GetIcuString(pattern, icuStr);
+ __pIcuDateFormatter->applyPattern(icuStr);
+ return E_SUCCESS;
}
String
_DateTimeFormatterImpl::GetPattern(void) const
{
- return __pLocaleData->GetDateTimePattern();
+ SysAssertf(__pIcuDateFormatter != null, "Not yet constructed! Construct() should be called before use.");
+ IcuUnicodeString icuPattern;
+ icuPattern = __pIcuDateFormatter->toPattern(icuPattern);
+ return _LocaleData::GetOspString(icuPattern);
}
const DateTimeSymbols*
-_DateTimeFormatterImpl::GetDateTimeSymbols(void) const
+_DateTimeFormatterImpl::GetDateTimeSymbols(void)
{
+ SysAssertf(__pIcuDateFormatter != null, "Not yet constructed! Construct() should be called before use.");
+ if (__pSymbols == null)
+ {
+ std::unique_ptr< DateTimeSymbols > pSymbols(new (std::nothrow) DateTimeSymbols);
+ SysTryReturn(NID_LCL, pSymbols, null, E_OUT_OF_MEMORY, "It is not enough memory.");
+ pSymbols->Construct(*__pLocale);
+ __pSymbols = pSymbols.release();
+ }
return __pSymbols;
}
void
_DateTimeFormatterImpl::SetDateTimeSymbols(const DateTimeSymbols& newSymbols)
{
- SysAssertf(__pLocaleData != null, "Not yet constructed! Construct() should be called before use.");
+ SysAssertf(__pIcuDateFormatter != null, "Not yet constructed! Construct() should be called before use.");
+
+ std::unique_ptr< DateTimeSymbols > pSymbols(new (std::nothrow) DateTimeSymbols);
+ SysTryReturn(NID_LCL, pSymbols, , E_OUT_OF_MEMORY, "It is not enough memory.");
+ result r = pSymbols->Construct(newSymbols);
+ SysTryReturn(NID_LCL, r == E_SUCCESS, , r, "[%s] occured.", GetErrorMessage(r));
+
+ _DateTimeSymbolsImpl* pDateTimeSymbolsImpl = _DateTimeSymbolsImpl::GetDateTimeSymbolsImpl(pSymbols.get());
+ const U_ICU_NAMESPACE::DateFormatSymbols* pIcuSymbols = pDateTimeSymbolsImpl->GetIcuSymbols();
+
+ __pIcuDateFormatter->setDateFormatSymbols(*pIcuSymbols);
- result r = __pLocaleData->SetDateTimeSymbols(newSymbols); // Set symbols to ICU date formatter
- if (!IsFailed(r))
+ if (__pSymbols)
{
- if (__pSymbols)
- {
- __pSymbols = __pLocaleData->GetDateTimeSymbolsN(__pSymbols); // Set __pSymbols obtained from ICU date formatter
- }
+ delete __pSymbols;
}
+ __pSymbols = pSymbols.release();
}
bool
_DateTimeFormatterImpl::ValidateDateTimeStyle(DateTimeStyle dateTimeStyle)
{
- return (dateTimeStyle < DATE_TIME_STYLE_NONE || dateTimeStyle > DATE_TIME_STYLE_SHORT)? false : true;
+ return (dateTimeStyle < DATE_TIME_STYLE_NONE || dateTimeStyle > DATE_TIME_STYLE_SHORT) ? false : true;
}
};
};
};
+namespace U_ICU_NAMESPACE
+{
+ class SimpleDateFormat;
+}
namespace Tizen { namespace Locales
{
* @return A pointer to DateTimeSymbols for the formatter instance
* @see SetDateTimeSymbols()
*/
- const DateTimeSymbols* GetDateTimeSymbols(void) const;
+ const DateTimeSymbols* GetDateTimeSymbols(void);
/**
_DateTimeFormatterImpl(const _DateTimeFormatterImpl& dateTimeFormatterImpl);
_DateTimeFormatterImpl& operator =(const _DateTimeFormatterImpl& dateTimeFormatterImpl);
-// Attribute
- _LocaleData* __pLocaleData;
- DateTimeSymbols* __pSymbols;
+ U_ICU_NAMESPACE::SimpleDateFormat* GetIcuDateFormatterN(const Locale& locale, DateTimeStyle dateStyle, DateTimeStyle timeStyle);
+private:
+ DateTimeSymbols* __pSymbols;
+ U_ICU_NAMESPACE::SimpleDateFormat* __pIcuDateFormatter;
+ Locale* __pLocale;
}; // _DateTimeFormatterImpl
};
}; // Tizen::Locales
{
SysTryReturnResult(NID_LCL, _LocaleImpl::IsSupported(locale), E_INVALID_ARG, "Given locale is not supported");
- _LocaleData localeData;
- result r = localeData.SetDateFormatSymbols(locale); // this will set ICU DateTimeSymbol in _LocaleData object for future use
-
- if (!IsFailed(r))
- {
- __pErasList = localeData.GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_ERA_LIST);
- __pMonthsList = localeData.GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_MONTH_LIST);
- __pShortMonthsList = localeData.GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_SHORT_MONTH_LIST);
- __pWeekdaysList = localeData.GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_WEEKDAY_LIST);
- __pShortWeekdaysList = localeData.GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_SHORT_WEEKDAY_LIST);
- __pAmPmList = localeData.GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_AM_PM_LIST);
- __CalendarType = calendarType;
-
- UErrorCode ec = U_ZERO_ERROR;
- __pIcuDateFormatSymbols = new IcuDateFormatSymbols(ec);
- }
-
- return r;
+ UErrorCode ec = U_ZERO_ERROR;
+ __pIcuDateFormatSymbols = new U_ICU_NAMESPACE::DateFormatSymbols(_LocaleData::GetIcuLocale(locale), ec);
+ SysTryReturnResult(NID_LCL, __pIcuDateFormatSymbols, E_OUT_OF_MEMORY, "It is not enough memory.");
+
+ __pErasList = GetSymbolAttributeArrayN(DATE_FORMAT_SYM_ERA_LIST);
+ __pMonthsList = GetSymbolAttributeArrayN(DATE_FORMAT_SYM_MONTH_LIST);
+ __pShortMonthsList = GetSymbolAttributeArrayN(DATE_FORMAT_SYM_SHORT_MONTH_LIST);
+ __pWeekdaysList = GetSymbolAttributeArrayN(DATE_FORMAT_SYM_WEEKDAY_LIST);
+ __pShortWeekdaysList = GetSymbolAttributeArrayN(DATE_FORMAT_SYM_SHORT_WEEKDAY_LIST);
+ __pAmPmList = GetSymbolAttributeArrayN(DATE_FORMAT_SYM_AM_PM_LIST);
+ __CalendarType = calendarType;
+
+ return E_SUCCESS;
}
void
{
SysTryReturnVoidResult(NID_LCL, pOther != null, E_INVALID_ARG,
"[%s] Invalid argument is used. pOther instance is invalid", GetErrorMessage(E_INVALID_ARG));
+ ReleaseAll();
- __pErasList = CloneArrayListN(pOther->__pErasList); // Copying EraList
- __pMonthsList = CloneArrayListN(pOther->__pMonthsList); // Copying Month List
- __pShortMonthsList = CloneArrayListN(pOther->__pShortMonthsList); // Copying Short Month List
- __pWeekdaysList = CloneArrayListN(pOther->__pWeekdaysList); // Copying Weekdays List
- __pShortWeekdaysList = CloneArrayListN(pOther->__pShortWeekdaysList); // Copying Short Weekdays List
- __pAmPmList = CloneArrayListN(pOther->__pAmPmList); // Copying AM/ PM String
+ __pErasList = CloneArrayListN(pOther->__pErasList);
+ __pMonthsList = CloneArrayListN(pOther->__pMonthsList);
+ __pShortMonthsList = CloneArrayListN(pOther->__pShortMonthsList);
+ __pWeekdaysList = CloneArrayListN(pOther->__pWeekdaysList);
+ __pShortWeekdaysList = CloneArrayListN(pOther->__pShortWeekdaysList);
+ __pAmPmList = CloneArrayListN(pOther->__pAmPmList);
if(pOther->__pTimeZonesMap)
{
- __pTimeZonesMap = CloneMultiHashMapN(pOther->__pTimeZonesMap); // Copying available TimeZone List
+ __pTimeZonesMap = CloneMultiHashMapN(pOther->__pTimeZonesMap);
}
- __CalendarType = pOther->__CalendarType; // Copying Calendar Type
+ __CalendarType = pOther->__CalendarType;
+
+ if(__pIcuDateFormatSymbols)
+ {
+ delete __pIcuDateFormatSymbols;
+ __pIcuDateFormatSymbols = null;
+ }
+ _DateTimeSymbolsImpl* pDTS = const_cast<_DateTimeSymbolsImpl*>(pOther);
+ __pIcuDateFormatSymbols = new U_ICU_NAMESPACE::DateFormatSymbols(*(pDTS->GetIcuSymbols()));
+ SysTryReturnVoidResult(NID_LCL, __pIcuDateFormatSymbols, E_OUT_OF_MEMORY, "It is not enough memory.");
}
if (!__pTimeZonesMap)
{
- MultiHashMap* pMultiHashMap = new (std::nothrow) MultiHashMap();
+ MultiHashMap* pMultiHashMap = new (std::nothrow) MultiHashMap(SingleObjectDeleter);
SysTryReturnResult(NID_LCL, pMultiHashMap, E_OUT_OF_MEMORY, "Memory allocation failed.");
pMultiHashMap->Construct();
{
SysAssertf(__pAmPmList != null, "Not yet constructed! Construct() should be called before use");
- ClearLastResult(); // Setting Last result to E_SUCCESS
+ ClearLastResult();
return __pAmPmList;
}
{
SysAssertf(__pAmPmList != null, "Not yet constructed! Construct() should be called before use");
- std::unique_ptr< ArrayList, AllElementsDeleter > pTempArrayList(new (std::nothrow) ArrayList());
+ std::unique_ptr< ArrayList > pTempArrayList(new (std::nothrow) ArrayList(SingleObjectDeleter));
SysTryReturnResult(NID_LCL, pTempArrayList != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
result r = SetList(pTempArrayList.get(), AM_PM_COUNT, amPm);
if (!IsFailed(r))
{
- __pAmPmList->RemoveAll(true);
delete __pAmPmList;
__pAmPmList = pTempArrayList.release();
+ int count = 0;
+ U_ICU_NAMESPACE::UnicodeString* pIcuArray = _LocaleData::ConvertOspArrayToIcuStringArrayN(__pAmPmList, count);
+ __pIcuDateFormatSymbols->setAmPmStrings(pIcuArray, count);
+ delete[] pIcuArray;
}
-
return r;
}
{
SysAssertf(__pErasList != null, "Not yet constructed! Construct() should be called before use");
- std::unique_ptr< ArrayList, AllElementsDeleter > pTempArrayList(new (std::nothrow) ArrayList());
+ std::unique_ptr< ArrayList > pTempArrayList(new (std::nothrow) ArrayList(SingleObjectDeleter));
SysTryReturnResult(NID_LCL, pTempArrayList != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
result r = SetList(pTempArrayList.get(), ERAS_COUNT, eras);
if (!IsFailed(r))
{
- __pErasList->RemoveAll(true);
delete __pErasList;
-
__pErasList = pTempArrayList.release();
+ int count = 0;
+ U_ICU_NAMESPACE::UnicodeString* pIcuArray = _LocaleData::ConvertOspArrayToIcuStringArrayN(__pErasList, count);
+ __pIcuDateFormatSymbols->setEras(pIcuArray, count);
+ delete[] pIcuArray;
}
return r;
{
SysAssertf(__pMonthsList != null, "Not yet constructed! Construct() should be called before use");
- ClearLastResult(); // Setting Last result to E_SUCCESS
+ ClearLastResult();
return __pMonthsList;
}
{
SysAssertf(__pMonthsList != null, "Not yet constructed! Construct() should be called before use");
- std::unique_ptr< ArrayList, AllElementsDeleter > pTempArrayList(new (std::nothrow) ArrayList());
+ std::unique_ptr< ArrayList > pTempArrayList(new (std::nothrow) ArrayList(SingleObjectDeleter));
SysTryReturnResult(NID_LCL, pTempArrayList != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
result r = SetList(pTempArrayList.get(), MONTH_COUNT, months);
if (!IsFailed(r))
{
- __pMonthsList->RemoveAll(true);
delete __pMonthsList;
-
__pMonthsList = pTempArrayList.release();
+ int count = 0;
+ U_ICU_NAMESPACE::UnicodeString* pIcuArray = _LocaleData::ConvertOspArrayToIcuStringArrayN(__pMonthsList, count);
+ __pIcuDateFormatSymbols->setMonths(pIcuArray, count);
+ delete[] pIcuArray;
}
return r;
{
SysAssertf(__pShortMonthsList != null, "Not yet constructed! Construct() should be called before use");
- ClearLastResult(); // Setting Last result to E_SUCCESS
+ ClearLastResult();
return __pShortMonthsList;
}
{
SysAssertf(__pShortMonthsList != null, "Not yet constructed! Construct() should be called before use");
- std::unique_ptr< ArrayList, AllElementsDeleter > pTempArrayList(new (std::nothrow) ArrayList());
+ std::unique_ptr< ArrayList > pTempArrayList(new (std::nothrow) ArrayList(SingleObjectDeleter));
SysTryReturnResult(NID_LCL, pTempArrayList != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
result r = SetList(pTempArrayList.get(), MONTH_COUNT, shortMonths);
if (!IsFailed(r))
{
- __pShortMonthsList->RemoveAll(true);
delete __pShortMonthsList;
-
__pShortMonthsList = pTempArrayList.release();
+ int count = 0;
+ U_ICU_NAMESPACE::UnicodeString* pIcuArray = _LocaleData::ConvertOspArrayToIcuStringArrayN(__pShortMonthsList, count);
+ __pIcuDateFormatSymbols->setShortMonths(pIcuArray, count);
+ delete[] pIcuArray;
}
return r;
{
SysAssertf(__pWeekdaysList != null, "Not yet constructed! Construct() should be called before use");
- ClearLastResult(); // Setting Last result to E_SUCCESS
+ ClearLastResult();
return __pWeekdaysList;
}
{
SysAssertf(__pWeekdaysList != null, "Not yet constructed! Construct() should be called before use");
- std::unique_ptr< ArrayList, AllElementsDeleter > pTempArrayList(new (std::nothrow) ArrayList());
+ std::unique_ptr< ArrayList > pTempArrayList(new (std::nothrow) ArrayList(SingleObjectDeleter));
SysTryReturnResult(NID_LCL, pTempArrayList != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
result r = SetList(pTempArrayList.get(), WEEKDAYS_COUNT, weekdays);
if (!IsFailed(r))
{
- __pWeekdaysList->RemoveAll(true);
delete __pWeekdaysList;
-
__pWeekdaysList = pTempArrayList.release();
+ int count = 0;
+ U_ICU_NAMESPACE::UnicodeString* pIcuArray = _LocaleData::ConvertOspArrayToIcuStringArrayN(__pWeekdaysList, count);
+ __pIcuDateFormatSymbols->setWeekdays(pIcuArray, count);
+ delete[] pIcuArray;
}
return r;
_DateTimeSymbolsImpl::GetShortWeekdays(void) const
{
SysAssertf(__pShortWeekdaysList != null, "Not yet constructed! Construct() should be called before use");
-
- ClearLastResult(); // Setting Last result to E_SUCCESS
+ ClearLastResult();
return __pShortWeekdaysList;
}
{
SysAssertf(__pShortWeekdaysList != null, "Not yet constructed! Construct() should be called before use");
- std::unique_ptr< ArrayList, AllElementsDeleter > pTempArrayList(new (std::nothrow) ArrayList());
+ std::unique_ptr< ArrayList > pTempArrayList(new (std::nothrow) ArrayList(SingleObjectDeleter));
SysTryReturnResult(NID_LCL, pTempArrayList != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
result r = SetList(pTempArrayList.get(), WEEKDAYS_COUNT, shortWeekdays);
if (!IsFailed(r))
{
- __pShortWeekdaysList->RemoveAll(true);
delete __pShortWeekdaysList;
-
__pShortWeekdaysList = pTempArrayList.release();
+ int count = 0;
+ U_ICU_NAMESPACE::UnicodeString* pIcuArray = _LocaleData::ConvertOspArrayToIcuStringArrayN(__pShortWeekdaysList, count);
+ __pIcuDateFormatSymbols->setShortWeekdays(pIcuArray, count);
+ delete[] pIcuArray;
}
return r;
result
_DateTimeSymbolsImpl::SetTimeZoneName(const Tizen::Base::String& timeZoneId, const Tizen::Base::String& concatenatedTimeZoneName)
{
- // checking if concatenatedTimeZoneName has 4 names
StringTokenizer tokenizer(concatenatedTimeZoneName, L"|");
SysTryReturnResult(NID_LCL, (tokenizer.GetTokenCount() == MAX_TIMEZONE_NAME),
E_INVALID_ARG, "Invalid argument is used. %ls is invalid.", concatenatedTimeZoneName.GetPointer());
}
-// internal function
-// This function makes a copy of input array list of strings
IList*
_DateTimeSymbolsImpl::CloneArrayListN(const IList* pList) const
{
SysTryReturn(NID_LCL, pList, null, E_INVALID_ARG, "[%s] Invalid argument is used. pList is Null", GetErrorMessage(E_INVALID_ARG));
- ClearLastResult(); // Setting last result to E_SUCCESS
- std::unique_ptr< ArrayList, AllElementsDeleter > pClonedArrayList(new (std::nothrow) ArrayList());
+ ClearLastResult();
+ std::unique_ptr< ArrayList > pClonedArrayList(new (std::nothrow) ArrayList(SingleObjectDeleter));
SysTryReturn(NID_LCL, pClonedArrayList, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
result r = pClonedArrayList->Construct(pList->GetCount());
ClearLastResult();
- std::unique_ptr< MultiHashMap, AllElementsDeleter > pClonedMultiHashMap(new (std::nothrow) MultiHashMap());
+ std::unique_ptr< MultiHashMap > pClonedMultiHashMap(new (std::nothrow) MultiHashMap(SingleObjectDeleter));
SysTryReturn(NID_LCL, pClonedMultiHashMap, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
result r = pClonedMultiHashMap->Construct();
SysTryReturnResult(NID_LCL, (tokenizer.GetTokenCount() == tokenCount), E_INVALID_ARG,
"Invalid argument is used. stringWillBeTokenized=%ls", stringWillBeTokenized.GetPointer());
+ SysTryReturnResult(NID_LCL, pArrayList, E_INVALID_ARG, "Invalid argument is used. pArrayList should not be null");
- std::unique_ptr< ArrayList, AllElementsDeleter > pTmpArrayList(pArrayList);
- SysTryReturnResult(NID_LCL, pTmpArrayList, E_INVALID_ARG, "Invalid argument is used. pArrayList should not be null");
-
- result r = pTmpArrayList->Construct(tokenCount); // Constructing list for tokenCount elements
+ result r = pArrayList->Construct(tokenCount);
if (!IsFailed(r))
{
String token;
pListStr.reset(new (std::nothrow) String(token));
SysTryReturnResult(NID_LCL, pListStr, E_OUT_OF_MEMORY, "Memory allocation failed.");
- r = pTmpArrayList->Add(pListStr.get());
+ r = pArrayList->Add(pListStr.get());
SysTryReturnResult(NID_LCL, r == E_SUCCESS, r, "Failed to add value to array list.");
pListStr.release();
}
}
-
- pTmpArrayList.release();
return r;
}
{
if (pList)
{
- pList->RemoveAll(true); // Remove elements and de-allocate memory used by them
delete pList;
+ pList = null;
}
}
-// This function release all the list after deleting their contents
void
_DateTimeSymbolsImpl::ReleaseAll(void)
{
- ReleaseList(__pErasList); // Deleting EraList after deleting its contents
- ReleaseList(__pMonthsList); // Deleting MonthsList after deleting its contents
- ReleaseList(__pShortMonthsList); // Deleting ShortMonthsList after deleting its contents
- ReleaseList(__pWeekdaysList); // Deleting WeekdaysList after deleting its contents
- ReleaseList(__pShortWeekdaysList); // Deleting ShortWeekdaysList after deleting its contents
- ReleaseList(__pAmPmList); // Deleting AmPmList after deleting its contents
+ ReleaseList(__pErasList);
+ ReleaseList(__pMonthsList);
+ ReleaseList(__pShortMonthsList);
+ ReleaseList(__pWeekdaysList);
+ ReleaseList(__pShortWeekdaysList);
+ ReleaseList(__pAmPmList);
if (__pTimeZonesMap)
{
- __pTimeZonesMap->RemoveAll(true); // Removing and deleting contents of TimeZonesMap
- delete __pTimeZonesMap; // Deleting TimeZonesMap
+ delete __pTimeZonesMap;
+ __pTimeZonesMap = null;
}
}
return pDateTimeSymbols->__pDateTimeSymbolsImpl;
}
+U_ICU_NAMESPACE::DateFormatSymbols*
+_DateTimeSymbolsImpl::GetIcuSymbols(void)
+{
+ return __pIcuDateFormatSymbols;
+}
+
+Tizen::Base::Collection::IList*
+_DateTimeSymbolsImpl::GetSymbolAttributeArrayN(DateFormatSymbolsAttributes attributeName)
+{
+ SysTryReturn(NID_LCL, __pIcuDateFormatSymbols, null, E_SYSTEM, "It is not initialized.");
+ ClearLastResult();
+ int count = 0;
+ const IcuUnicodeString* pIcuList = null;
+
+ switch (attributeName)
+ {
+ case DATE_FORMAT_SYM_ERA_LIST:
+ {
+ pIcuList = __pIcuDateFormatSymbols->getEras(count);
+ break;
+ }
+ case DATE_FORMAT_SYM_MONTH_LIST:
+ {
+ pIcuList = __pIcuDateFormatSymbols->getMonths(count);
+ break;
+ }
+ case DATE_FORMAT_SYM_SHORT_MONTH_LIST:
+ {
+ pIcuList = __pIcuDateFormatSymbols->getShortMonths(count);
+ break;
+ }
+ case DATE_FORMAT_SYM_WEEKDAY_LIST:
+ {
+ pIcuList = __pIcuDateFormatSymbols->getWeekdays(count);
+ break;
+ }
+ case DATE_FORMAT_SYM_SHORT_WEEKDAY_LIST:
+ {
+ pIcuList = __pIcuDateFormatSymbols->getShortWeekdays(count);
+ break;
+ }
+ case DATE_FORMAT_SYM_AM_PM_LIST:
+ {
+ pIcuList = __pIcuDateFormatSymbols->getAmPmStrings(count);
+ break;
+ }
+ default:
+ {
+ SetLastResult(E_UNSUPPORTED_OPERATION);
+ break;
+ }
+ }
+
+ SysTryReturn(NID_LCL, pIcuList, null, E_SYSTEM, "It is faile to get symbols.");
+ return _LocaleData::ConvertIcuStringArrayToOspArrayN(pIcuList, count);
+}
+
+
};
}; // Tizen::Locale
#include <FLclLocale.h>
#include <FLclCalendar.h>
+namespace U_ICU_NAMESPACE
+{
+ class UnicodeString;
+ class DateFormatSymbols;
+}
namespace Tizen { namespace Locales
{
{
public:
-// Construct Operations
_DateTimeSymbolsImpl(void);
virtual ~_DateTimeSymbolsImpl(void);
void ReleaseList(Tizen::Base::Collection::IList* pList);
void ReleaseAll();
+ U_ICU_NAMESPACE::DateFormatSymbols* GetIcuSymbols(void);
static _DateTimeSymbolsImpl* GetDateTimeSymbolsImpl(DateTimeSymbols* pDateTimeSymbols);
private:
_DateTimeSymbolsImpl(const _DateTimeSymbolsImpl& dateTimeSymbolsImpl);
_DateTimeSymbolsImpl& operator =(const _DateTimeSymbolsImpl& dateTimeSymbolsImpl);
-// Attribute
+ Tizen::Base::Collection::IList* GetSymbolAttributeArrayN(DateFormatSymbolsAttributes attributeName);
+
+private:
Tizen::Base::Collection::IList* __pErasList;
Tizen::Base::Collection::IList* __pMonthsList;
Tizen::Base::Collection::IList* __pShortMonthsList;
#include <FLclNumberSymbols.h>
#include <FApp_AppInfo.h>
#include "FBase_StringConverter.h"
-#include "FLcl_DateTimeSymbolsImpl.h"
#include "FLcl_CalendarImpl.h"
#include "FLcl_IcuCalendarImpl.h"
#include "FLcl_LocaleData.h"
{
IcuUnicodeString icuStr;
- if (!ospStr.IsEmpty()) // if ospStr is not empty
- {
- ByteBuffer* pBuff = null;
- pBuff = StringUtil::StringToUtf8N(ospStr); // Convert unicode value to UTF8
- if (pBuff)
- {
- icuStr = IcuUnicodeString((const char*) pBuff->GetPointer()); // Create ICU string using UTF8 array
- icuStr.setCharAt(0, icuStr.charAt(0)); // This is to handle ICU copy on write design
- delete pBuff; // delete temporary buffer
- }
- }
-
- return icuStr;
+ if (!ospStr.IsEmpty()) // if ospStr is not empty
+ {
+ ByteBuffer* pBuff = null;
+ pBuff = StringUtil::StringToUtf8N(ospStr); // Convert unicode value to UTF8
+ if (pBuff)
+ {
+ icuStr = IcuUnicodeString((const char*) pBuff->GetPointer()); // Create ICU string using UTF8 array
+ icuStr.setCharAt(0, icuStr.charAt(0)); // This is to handle ICU copy on write design
+ delete pBuff; // delete temporary buffer
+ }
+ }
+
+ return icuStr;
}
// This function convert ICU string to OSP string
return pTempArrayList.release(); // Return array list
}
-// this function convert OSP string array list to ICU string array list
IcuUnicodeString*
_LocaleData::ConvertOspArrayToIcuStringArrayN(const Tizen::Base::Collection::IList* pIcuStrList, int& count)
{
- count = 0; // Setting count [Out param] to 0
+ count = 0;
SysTryReturn(NID_LCL, pIcuStrList, null, E_INVALID_ARG, "[%s] Invalid argument is used. pIcuStrList is null.", GetErrorMessage(E_INVALID_ARG));
count = pIcuStrList->GetCount();
- if (count > 0) // if pIcuStrList is not empty
+ SysTryReturn(NID_LCL, count > 0, null, E_INVALID_ARG, "The list is empty.");
+
+ std::unique_ptr< IcuUnicodeString[] > pIcuStrArray(new IcuUnicodeString[count]);
+ SysTryReturn(NID_LCL, pIcuStrArray, null, E_OUT_OF_MEMORY, "It is not enough memory.");
+
+ std::unique_ptr< IEnumerator > pEnum(pIcuStrList->GetEnumeratorN());
+ SysTryReturn(NID_LCL, pEnum, null, E_SYSTEM, "It is failed to get enumerator.");
+
+ int i = 0;
+ String* pObj = null;
+ while (pEnum->MoveNext() == E_SUCCESS)
{
- IcuUnicodeString* pIcuStrArray = new IcuUnicodeString[count];
- if (pIcuStrArray) // if allocation is successful
+ pObj = static_cast< String* >(pEnum->GetCurrent());
+ if (pObj)
{
- IEnumerator* pEnum = pIcuStrList->GetEnumeratorN();
- if (pEnum) // if pEnum is non null
- {
- int i = 0;
- String* pObj = null;
- while (pEnum->MoveNext() == E_SUCCESS) // if enum has more value
- {
- pObj = static_cast< String* >(pEnum->GetCurrent()); // Get object and cast it to String
- if (pObj) // if String is non null
- {
- GetIcuString(*pObj, pIcuStrArray[i]); // Convert it to ICU string and set to array
- i++;
- }
- }
-
- delete pEnum; // Delete enumerator
- return pIcuStrArray; // return ICU Array
- }
- delete[] pIcuStrArray;
+ GetIcuString(*pObj, pIcuStrArray[i]);
+ i++;
}
}
-
- return null; // return null in case of failure
+ return pIcuStrArray.release();
}
}
}
-result
-_LocaleData::SetDateFormatSymbols(const Locale& locale)
-{
- if (__pIcuDateFormatSymbols)
- {
- delete __pIcuDateFormatSymbols;
- __pIcuDateFormatSymbols = null;
- }
-
- UErrorCode ec = U_ZERO_ERROR;
- result r = SetLocale(locale);
-
- if (!IsFailed(r))
- {
- __pIcuDateFormatSymbols = new IcuDateFormatSymbols(__icuLocale, ec);
-
- if (__pIcuDateFormatSymbols && U_SUCCESS(ec))
- {
- return E_SUCCESS;
- }
- }
-
- delete __pIcuDateFormatSymbols;
- __pIcuDateFormatSymbols = null;
-
- return r;
-}
-
-IList*
-_LocaleData::GetDateFormatSymbolAttrArrayN(DateFormatSymbolsAttributes attrName)
-{
- if (__pIcuDateFormatSymbols)
- {
- ClearLastResult();
- int count = 0;
- const IcuUnicodeString* pIcuList = null;
-
- switch (attrName)
- {
- case DATE_FORMAT_SYM_ERA_LIST:
- {
- pIcuList = __pIcuDateFormatSymbols->getEras(count);
- break;
- }
-
- case DATE_FORMAT_SYM_MONTH_LIST:
- {
- pIcuList = __pIcuDateFormatSymbols->getMonths(count);
- break;
- }
-
- case DATE_FORMAT_SYM_SHORT_MONTH_LIST:
- {
- pIcuList = __pIcuDateFormatSymbols->getShortMonths(count);
- break;
- }
-
- case DATE_FORMAT_SYM_WEEKDAY_LIST:
- {
- pIcuList = __pIcuDateFormatSymbols->getWeekdays(count);
- break;
- }
-
- case DATE_FORMAT_SYM_SHORT_WEEKDAY_LIST:
- {
- pIcuList = __pIcuDateFormatSymbols->getShortWeekdays(count);
- break;
- }
-
- case DATE_FORMAT_SYM_AM_PM_LIST:
- {
- pIcuList = __pIcuDateFormatSymbols->getAmPmStrings(count);
- break;
- }
-
- default:
- {
- SetLastResult(E_UNSUPPORTED_OPERATION);
- break;
- }
- }
-
- if (pIcuList)
- {
- return ConvertIcuStringArrayToOspArrayN(pIcuList, count);
- }
- }
-
- SetLastResult(E_INVALID_STATE);
- return null;
-}
-
IcuUDate
_LocaleData::GetIcuDate(DateTime date)
return icuDate;
}
-result
-_LocaleData::SetDateTimeFormatter(DateTimeStyle dateStyle, DateTimeStyle timeStyle, const Locale& locale)
-{
- IcuDateFormat* pIcuDateFormat = null;
-
- result r = SetLocale(locale);
- SysTryReturnResult(NID_LCL, !IsFailed(r), E_INVALID_ARG, "Locale setting failed.");
-
- U_ICU_NAMESPACE::DateFormat::EStyle icuDateStyle = (U_ICU_NAMESPACE::DateFormat::EStyle) dateStyle;
- U_ICU_NAMESPACE::DateFormat::EStyle icuTimeStyle = (U_ICU_NAMESPACE::DateFormat::EStyle) timeStyle;
-
- if (dateStyle == DATE_TIME_STYLE_NONE)
- {
- if (timeStyle != DATE_TIME_STYLE_NONE)
- {
- pIcuDateFormat = IcuDateFormat::createTimeInstance(icuTimeStyle, __icuLocale);
- }
- }
- else
- {
- if (timeStyle == DATE_TIME_STYLE_NONE)
- {
- pIcuDateFormat = IcuDateFormat::createDateInstance(icuDateStyle, __icuLocale);
- }
- else
- {
- pIcuDateFormat = IcuDateFormat::createDateTimeInstance(icuDateStyle, icuTimeStyle, __icuLocale);
- }
- }
-
- if (pIcuDateFormat)
- {
- if (__pIcuDateFormat)
- {
- delete __pIcuDateFormat;
- __pIcuDateFormat = null;
- }
- __pIcuDateFormat = dynamic_cast< IcuSimpleDateFormat* >(pIcuDateFormat);
-
- if (__pIcuDateFormat)
- {
- if (__pIcuDateFormatSymbols)
- {
- delete __pIcuDateFormatSymbols;
- __pIcuDateFormatSymbols = null;
- }
-
- const IcuDateFormatSymbols* pDateTimeFormatSym = __pIcuDateFormat->getDateFormatSymbols();
-
- if (pDateTimeFormatSym)
- {
- __pIcuDateFormatSymbols = new IcuDateFormatSymbols(*pDateTimeFormatSym);
- }
-
- return E_SUCCESS;
- }
- }
-
- delete pIcuDateFormat;
- return E_INVALID_ARG;
-}
-
-
-result
-_LocaleData::FormatDateTime(const DateTime& date, String& str)
-{
- std::auto_ptr <Calendar> pCal(Calendar::CreateInstanceN());
- SysTryReturnResult(NID_LCL, pCal.get(), E_OUT_OF_MEMORY, "Memory allocation failed");
-
- result r = pCal->SetTime(date);
- SysTryReturn(NID_LCL, r == E_SUCCESS, r, r, "[%s] Unable to set date time in default calendar");
-
- r = pCal->Clear(TIME_FIELD_MILLISECOND);
- SysTryReturn(NID_LCL, r == E_SUCCESS, r, r, "[%s] Unable to set date time in default calendar");
-
- return FormatDateTime(*pCal, str);
-}
-
-result
-_LocaleData::FormatDateTime(const Calendar& calendar, Tizen::Base::String& str)
-{
- SysTryReturnResult(NID_LCL, __pIcuDateFormat, E_INVALID_STATE, "This instance is not constructed");
- ClearLastResult();
-
- const _IcuCalendarImpl* _pIcuCalendarImpl = _CalendarImpl::GetImpl(calendar);
- if (_pIcuCalendarImpl)
- {
- IcuCalendar* pIcuCal = _pIcuCalendarImpl->GetIcuCalendarCloneN();
- if (pIcuCal)
- {
- IcuFieldPosition icuFp;
- IcuUnicodeString icuStr;
-
- GetIcuString(str,icuStr);
- icuStr = __pIcuDateFormat->format(*pIcuCal, icuStr, icuFp);
- str = _LocaleData::GetOspString(icuStr);
-
- delete pIcuCal;
- return GetLastResult();
- }
- }
-
- return E_SYSTEM;
-}
-
-String
-_LocaleData::GetDateTimePattern()
-{
- SysTryReturn(NID_LCL, __pIcuDateFormat, String(""), E_INVALID_STATE, "This instance is not constructed");
- IcuUnicodeString icuPattern;
-
- icuPattern = __pIcuDateFormat->toPattern(icuPattern);
- return _LocaleData::GetOspString(icuPattern);
-}
-
-result
-_LocaleData::SetDateTimePattern(const String& pattern)
-{
- SysTryReturnResult(NID_LCL, __pIcuDateFormat, E_INVALID_STATE, "This instance is not constructed");
- IcuUnicodeString icuStr;
-
- GetIcuString(pattern, icuStr);
-
- __pIcuDateFormat->applyPattern(icuStr);
-
- return E_SUCCESS;
-}
-DateTimeSymbols*
-_LocaleData::GetDateTimeSymbolsN(DateTimeSymbols* pDateTimeSymbols)
-{
- SysTryReturn(NID_LCL, __pIcuDateFormatSymbols, null, E_INVALID_STATE, "[E_INVALID_STATE] This instance is not constructed");
- SysTryReturn(NID_LCL, pDateTimeSymbols, null, E_INVALID_ARG, "[%s] Invalid argument is used. pDateTimeSymbols is null.", GetErrorMessage(E_INVALID_ARG));
-
- _DateTimeSymbolsImpl* pDateTimeSymbolsImpl = _DateTimeSymbolsImpl::GetDateTimeSymbolsImpl(pDateTimeSymbols);
-
- if (pDateTimeSymbolsImpl)
- {
- pDateTimeSymbolsImpl->ReleaseAll();
-
- pDateTimeSymbolsImpl->__pErasList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_ERA_LIST);
- pDateTimeSymbolsImpl->__pMonthsList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_MONTH_LIST);
- pDateTimeSymbolsImpl->__pShortMonthsList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_SHORT_MONTH_LIST);
- pDateTimeSymbolsImpl->__pWeekdaysList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_WEEKDAY_LIST);
- pDateTimeSymbolsImpl->__pShortWeekdaysList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_SHORT_WEEKDAY_LIST);
- pDateTimeSymbolsImpl->__pAmPmList = GetDateFormatSymbolAttrArrayN(DATE_FORMAT_SYM_AM_PM_LIST);
-
- return pDateTimeSymbols;
- }
-
- return null;
-}
-
-// This function convert and set ICU DateTime symbols from OSP DateTimeSymbols
-result
-_LocaleData::SetDateTimeSymbols(const DateTimeSymbols& newValue)
-{
- UErrorCode ec = U_ZERO_ERROR;
-
- if (!__pIcuDateFormatSymbols)
- {
- __pIcuDateFormatSymbols = new IcuDateFormatSymbols(ec);
- }
-
- IcuUnicodeString* pIcuArray = null;
- int count = 0;
-
- if (U_SUCCESS(ec) && __pIcuDateFormatSymbols != null)
- {
- pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetEras(), count);
- __pIcuDateFormatSymbols->setEras(pIcuArray, count);
- delete[] pIcuArray;
-
- pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetMonths(), count);
- __pIcuDateFormatSymbols->setMonths(pIcuArray, count);
- delete[] pIcuArray;
-
- pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetShortMonths(), count);
- __pIcuDateFormatSymbols->setShortMonths(pIcuArray, count);
- delete[] pIcuArray;
-
- pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetWeekdays(), count);
- __pIcuDateFormatSymbols->setWeekdays(pIcuArray, count);
- delete[] pIcuArray;
-
- pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetShortWeekdays(), count);
- __pIcuDateFormatSymbols->setShortWeekdays(pIcuArray, count);
- delete[] pIcuArray;
-
- pIcuArray = ConvertOspArrayToIcuStringArrayN(newValue.GetAmPm(), count);
- __pIcuDateFormatSymbols->setAmPmStrings(pIcuArray, count);
- delete[] pIcuArray;
-
-// From ICU Docs: SimpleDateFormat no longer use the zone strings stored in a DateFormatSymbols. Therefore, the time zone strings
-// set by this method have no effects in an instance of SimpleDateFormat for formatting time zones.
-// __pIcuDateFormatSymbols->setZoneStrings();
-
- __pIcuDateFormat->setDateFormatSymbols(*__pIcuDateFormatSymbols);
- return E_SUCCESS;
- }
-
- return E_UNSUPPORTED_OPERATION;
-}
-
-
_LocaleData::_LocaleData(void)
: __icuLocale()
- , // default ICU locale
- __pIcuNumberFormatter(null)
- , __pIcuDateFormatSymbols(null)
- , __pIcuDateFormat(null)
+ , __pIcuNumberFormatter(null)
{
}
delete __pIcuNumberFormatter;
__pIcuNumberFormatter = null;
}
-
- if (__pIcuDateFormatSymbols) // Delete __pIcuDateFormatSymbols and set to null
- {
- delete __pIcuDateFormatSymbols;
- __pIcuDateFormatSymbols = null;
- }
-
- if (__pIcuDateFormat) // Delete __pIcuDateFormat and set to null
- {
- delete __pIcuDateFormat;
- __pIcuDateFormat = null;
- }
}
// Includes
#include <unicode/locid.h>
-#include <unicode/timezone.h>
-#include <unicode/basictz.h>
-#include <unicode/simpletz.h>
#include <unicode/decimfmt.h>
-#include <unicode/dtfmtsym.h>
-#include <unicode/smpdtfmt.h>
#include <unicode/calendar.h>
#include <unicode/gregocal.h>
#include <FLclLocale.h>
-#include <FLclDateTimeSymbols.h>
-#include <FLclDateTimeFormatter.h>
+#include <FBaseDateTime.h>
#include <FBaseString.h>
#include <FBaseColHashMap.h>
#include <FBaseColArrayList.h>
#include "FLcl_NumberFormatterImpl.h"
-#include "FLcl_DateTimeSymbolsImpl.h"
#include "FLcl_FieldPosition.h"
typedef U_ICU_NAMESPACE::UnicodeString IcuUnicodeString;
typedef U_ICU_NAMESPACE::StringEnumeration IcuStringEnumeration;
typedef U_ICU_NAMESPACE::Locale IcuLocale;
-typedef U_ICU_NAMESPACE::TimeZone IcuTimeZone;
-typedef U_ICU_NAMESPACE::BasicTimeZone IcuBasicTimeZone;
-typedef U_ICU_NAMESPACE::SimpleTimeZone IcuSimpleTimeZone;
typedef U_ICU_NAMESPACE::DecimalFormatSymbols IcuDecimalFormatSymbols;
typedef U_ICU_NAMESPACE::Calendar IcuCalendar;
typedef U_ICU_NAMESPACE::GregorianCalendar IcuGregorianCalendar;
-typedef U_ICU_NAMESPACE::InitialTimeZoneRule IcuInitialTimeZoneRule;
-typedef U_ICU_NAMESPACE::AnnualTimeZoneRule IcuAnnualTimeZoneRule;
-typedef U_ICU_NAMESPACE::DateTimeRule IcuDateTimeRule;
typedef U_ICU_NAMESPACE::NumberFormat IcuNumberFormat;
typedef U_ICU_NAMESPACE::DecimalFormat IcuDecimalFormat;
typedef U_ICU_NAMESPACE::FieldPosition IcuFieldPosition;
-typedef U_ICU_NAMESPACE::DateFormatSymbols IcuDateFormatSymbols;
-typedef U_ICU_NAMESPACE::DateFormat IcuDateFormat;
-typedef U_ICU_NAMESPACE::SimpleDateFormat IcuSimpleDateFormat;
-
namespace Tizen { namespace Locales
{
/**
- * @enum DstRuleMode
- * Possible DST rule mode
- *
- * @since 1.0
- */
-enum DstRuleMode
-{
- EXACT_DAY = 0,
- DAY_OF_WEEK_IN_MONTH,
- AFTER_THE_SPECIFIED_DAY,
- BEFORE_THE_SPECIFIED_DAY,
- BACKWARD_FROM_END_OF_MONTH
-};
-
-/**
* @class _LocaleData
* @brief This class is for loading the @e locale data.
* @since 1.0
// Operations
private:
-
- Tizen::Base::Collection::ArrayList* ConvertIcuStringArrayToOspArrayN(const IcuUnicodeString* pIcuStrList, int count);
- IcuUnicodeString* ConvertOspArrayToIcuStringArrayN(const Tizen::Base::Collection::IList* pIcuStrList, int& count);
-
- // Methods to support Locale
const IcuLocale& GetIcuLocale(void);
- IcuLocale GetIcuLocale(const Tizen::Locales::Locale& ospLocale);
public:
static Tizen::Base::String GetOspString(const IcuUnicodeString& icuStr);
static U_ICU_NAMESPACE::UnicodeString GetIcuString(const Tizen::Base::String& ospString);
static void GetIcuString(const Tizen::Base::String& ospStr, IcuUnicodeString& icuStr);
+ static IcuUnicodeString* ConvertOspArrayToIcuStringArrayN(const Tizen::Base::Collection::IList* pIcuStrList, int& count);
+ static Tizen::Base::Collection::ArrayList* ConvertIcuStringArrayToOspArrayN(const IcuUnicodeString* pIcuStrList, int count);
static IcuUDate GetIcuDate(Tizen::Base::DateTime date);
static IcuFieldPosition GetIcuFieldPosition(_FieldPosition pos);
-
+ static IcuLocale GetIcuLocale(const Tizen::Locales::Locale& ospLocale);
// Methods to support Locale
bool IsLocaleSupported();
result SetLocale(const Locale& ospLocale);
bool GetNumberFormatterBoolAttributes(NumberFormatterAttributes attrName);
void SetNumberFormatterAttributes(const bool newValue, NumberFormatterAttributes attrName);
-
- // Methods to support DateTimeSymbols
- result SetDateFormatSymbols(const Locale& locale);
- Tizen::Base::Collection::IList* GetDateFormatSymbolAttrArrayN(DateFormatSymbolsAttributes attrName);
-
- // Methods to support DateTimeFormatter
- result SetDateTimeFormatter(DateTimeStyle dateStyle, DateTimeStyle timeStyle, const Locale& locale);
- result FormatDateTime(const Tizen::Base::DateTime& date, Tizen::Base::String& str);
- result FormatDateTime(const Calendar& calendar, Tizen::Base::String& str);
- Tizen::Base::String GetDateTimePattern();
- result SetDateTimePattern(const Tizen::Base::String& pattern);
- DateTimeSymbols* GetDateTimeSymbolsN(DateTimeSymbols* pDateTimeSymbols);
- result SetDateTimeSymbols(const DateTimeSymbols& newValue);
-
private:
_LocaleData(const _LocaleData& localeData);
_LocaleData& operator =(const _LocaleData& localeData);
private:
IcuLocale __icuLocale;
IcuDecimalFormat* __pIcuNumberFormatter;
- IcuDateFormatSymbols* __pIcuDateFormatSymbols;
- IcuSimpleDateFormat* __pIcuDateFormat;
-
}; // LocaleData
}} // Tizen::Locales
#include <runtime_info.h>
#include <unicode/calendar.h>
#include <unicode/timezone.h>
+#include <unicode/locid.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <vconf.h>
return Locale(LANGUAGE_INVALID, COUNTRY_INVALID, null);
}
+U_ICU_NAMESPACE::Locale
+_LocaleManagerImpl::GetSystemIcuLocale(void)
+{
+ char* pRegionPtr;
+ if (runtime_info_get_value_string(RUNTIME_INFO_KEY_REGION, &pRegionPtr) == RUNTIME_INFO_ERROR_NONE)
+ {
+ SetLastResult(E_SUCCESS);
+ U_ICU_NAMESPACE::Locale locale(pRegionPtr);
+
+ free(pRegionPtr);
+ return locale;
+ }
+ return U_ICU_NAMESPACE::Locale();
+}
+
IMap*
_LocaleManagerImpl::GetAvailableEglibcLocaesN(void)
*/
#include <unique_ptr.h>
+#include <unicode/timezone.h>
+#include <unicode/basictz.h>
+#include <unicode/simpletz.h>
+#include <FBaseInteger.h>
#include <FBaseSysLog.h>
#include <FLclTimeZone.h>
#include "FLcl_LocaleData.h"
#include "FLcl_TimeZoneImpl.h"
+typedef U_ICU_NAMESPACE::TimeZone IcuTimeZone;
+typedef U_ICU_NAMESPACE::BasicTimeZone IcuBasicTimeZone;
+typedef U_ICU_NAMESPACE::SimpleTimeZone IcuSimpleTimeZone;
+typedef U_ICU_NAMESPACE::InitialTimeZoneRule IcuInitialTimeZoneRule;
+typedef U_ICU_NAMESPACE::AnnualTimeZoneRule IcuAnnualTimeZoneRule;
+typedef U_ICU_NAMESPACE::DateTimeRule IcuDateTimeRule;
+
+enum DstRuleMode
+{
+ EXACT_DAY = 0,
+ DAY_OF_WEEK_IN_MONTH,
+ AFTER_THE_SPECIFIED_DAY,
+ BEFORE_THE_SPECIFIED_DAY,
+ BACKWARD_FROM_END_OF_MONTH
+};
+
using namespace Tizen::Base;
namespace Tizen { namespace Locales
namespace U_ICU_NAMESPACE
{
class StringEnumeration;
+class Locale;
}
namespace Tizen { namespace Locales
public:
static Tizen::Locales::Locale GetSystemLocale(void);
+ static U_ICU_NAMESPACE::Locale GetSystemIcuLocale(void);
+
static Tizen::Base::Collection::IList* GetAvailableLocalesN(void);
// Get available c-locale from file
static Tizen::Base::Collection::IMap* GetAvailableEglibcLocaesN(void);
projects / platform / framework / native / appfw.git / commitdiff