src/locales/FLcl_LocaleData.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   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
   7 //
   8 // http://www.apache.org/licenses/LICENSE-2.0
   9 //
  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.
  15 //
  16
  17 /**
  18  * @file        FLclLocaleData.cpp
  19  * @brief       This is the implementation file for _LocaleData class.
  20  */
  21
  22 // Includes
  23 #include <locale.h>
  24 #include <memory>
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27 #include <limits.h>
  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_CalendarImpl.h"
  36 #include "FLcl_IcuCalendarImpl.h"
  37 #include "FLcl_LocaleData.h"
  38 #include "FLcl_LocaleImpl.h"
  39
  40
  41 // Other defines
  42 #define LOCALE_DATA_NUM_OF_MILLISEC_IN_HOUR 3600000LL   // number of mili second in a hour
  43 #define LOCALE_DATA_NUM_OF_MILLISEC_IN_MINUTE 60000LL   // number of mili second in a minute
  44
  45 using namespace Tizen::Base;
  46 using namespace Tizen::Base::Collection;
  47 using namespace Tizen::Base::Utility;
  48
  49 namespace Tizen { namespace Locales
  50 {
  51
  52 /////////////////////////////////////////////////////////////////////////////////////////////////////
  53 // Public Method
  54
  55 // this function is to convert ICU FieldPosition from OSP _FieldPosition
  56 IcuFieldPosition
  57 _LocaleData::GetIcuFieldPosition(_FieldPosition pos)
  58 {
  59         IcuFieldPosition icuPos(pos.GetField());            // Create IcuFieldPosition with field value in pos
  60         icuPos.setBeginIndex(pos.GetBeginIndex());          // Set Beginning index
  61         icuPos.setEndIndex(pos.GetEndIndex());              // Set End index
  62         return icuPos;
  63 }
  64
  65 U_ICU_NAMESPACE::UnicodeString
  66 _LocaleData::GetIcuString(const String& ospStr)
  67 {
  68         IcuUnicodeString icuStr;
  69
  70         if (!ospStr.IsEmpty())                                                     // if ospStr is not empty
  71         {
  72                 ByteBuffer* pBuff = null;
  73                 pBuff = StringUtil::StringToUtf8N(ospStr);                             // Convert unicode value to UTF8
  74                 if (pBuff)
  75                 {
  76                         icuStr = IcuUnicodeString((const char*) pBuff->GetPointer());        // Create ICU string using UTF8 array
  77                         icuStr.setCharAt(0, icuStr.charAt(0));                              // This is to handle ICU copy on write design
  78                         delete pBuff;                                                       // delete temporary buffer
  79                 }
  80         }
  81
  82         return icuStr;
  83 }
  84
  85 // This function convert ICU string to OSP string
  86 String
  87 _LocaleData::GetOspString(const IcuUnicodeString& icuStr)
  88 {
  89         int len = icuStr.length();                                  // get length
  90         if (len > 0)                                                    // if icuStr is not empty
  91         {
  92                 wchar_t wstr[len + 1];
  93                 IcuUnicodeString tmpIcuStr(icuStr);
  94                 for (int i = 0; i < len ; i++)
  95                 {
  96                         UChar icuChar;
  97                         icuChar = tmpIcuStr.charAt(i);
  98                         wstr[i] = (wchar_t)icuChar;
  99                 }
 100                 wstr[len] = 0;
 101                 return String(wstr);
 102         }
 103         return String("");
 104 }
 105
 106 // This convert OSP string to ICU strings
 107 void
 108 _LocaleData::GetIcuString(const String& ospStr, IcuUnicodeString& icuStr)
 109 {
 110         if (!ospStr.IsEmpty())                                                     // if ospStr is not empty
 111         {
 112                 ByteBuffer* pBuff = null;
 113                 pBuff = StringUtil::StringToUtf8N(ospStr);                             // Convert unicode value to UTF8
 114                 if (pBuff)
 115                 {
 116                         icuStr = IcuUnicodeString((const char*) pBuff->GetPointer());        // Create ICU string using UTF8 array
 117                         icuStr.setCharAt(0, icuStr.charAt(0));                              // This is to handle ICU copy on write design
 118                         delete pBuff;                                                       // delete temporary buffer
 119                 }
 120         }
 121
 122 //      return icuStr;
 123 }
 124
 125 // This function return OSP array list of OSP string from ICU string list
 126 ArrayList*
 127 _LocaleData::ConvertIcuStringArrayToOspArrayN(const IcuUnicodeString* pIcuStrList, int count)
 128 {
 129         SysTryReturn(NID_LCL, pIcuStrList && count > 0, null, E_INVALID_ARG, "It is invalid argument.");
 130
 131         result r = E_SUCCESS;
 132         std::unique_ptr< ArrayList> pTempArrayList(new (std::nothrow) ArrayList(SingleObjectDeleter));
 133         SysTryReturn(NID_LCL, pTempArrayList, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 134         pTempArrayList->Construct(count);
 135
 136         for (int i = 0; i < count; i++)
 137         {
 138                 std::unique_ptr< String > pString(new (std::nothrow) String(_LocaleData::GetOspString(pIcuStrList[i])));
 139                 SysTryReturn(NID_LCL, pString, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 140
 141                 if (!pString->IsEmpty())
 142                 {
 143                         r = pTempArrayList->Add(pString.get());                    // Add OSP string to arraylist if it is not empty
 144                         SysTryReturn(NID_LCL, !IsFailed(r), null, E_SYSTEM, "It is failed to add string [%ls]", pString->GetPointer());
 145                         pString.release();
 146                 }
 147         }
 148
 149         SetLastResult(r);                                                           // Setting last result value
 150         return pTempArrayList.release();                                                      // Return array list
 151 }
 152
 153 IcuUnicodeString*
 154 _LocaleData::ConvertOspArrayToIcuStringArrayN(const Tizen::Base::Collection::IList* pIcuStrList, int& count)
 155 {
 156         count = 0;
 157         SysTryReturn(NID_LCL, pIcuStrList, null, E_INVALID_ARG, "[%s] Invalid argument is used. pIcuStrList is null.", GetErrorMessage(E_INVALID_ARG));
 158
 159         count = pIcuStrList->GetCount();
 160         SysTryReturn(NID_LCL, count > 0, null, E_INVALID_ARG, "The list is empty.");
 161
 162         std::unique_ptr< IcuUnicodeString[] > pIcuStrArray(new IcuUnicodeString[count]);
 163         SysTryReturn(NID_LCL, pIcuStrArray, null, E_OUT_OF_MEMORY, "It is not enough memory.");
 164
 165         std::unique_ptr< IEnumerator > pEnum(pIcuStrList->GetEnumeratorN());
 166         SysTryReturn(NID_LCL, pEnum, null, E_SYSTEM, "It is failed to get enumerator.");
 167
 168         int i = 0;
 169         String* pObj = null;
 170         while (pEnum->MoveNext() == E_SUCCESS)
 171         {
 172                 pObj = static_cast< String* >(pEnum->GetCurrent());
 173                 if (pObj)
 174                 {
 175                         GetIcuString(*pObj, pIcuStrArray[i]);
 176                         i++;
 177                 }
 178         }
 179         return pIcuStrArray.release();
 180 }
 181
 182
 183 IcuLocale
 184 _LocaleData::GetIcuLocale(const Locale& ospLocale)
 185 {
 186         ClearLastResult();
 187         String language = ospLocale.GetLanguageCodeString();
 188         String country = ospLocale.GetCountryCodeString();
 189         String variant = ospLocale.GetVariantCodeString();
 190
 191         const char* pLangStr = _StringConverter::CopyToCharArrayN(language);
 192         const char* pCountryStr = _StringConverter::CopyToCharArrayN(country);
 193         const char* pVariantStr = null;
 194
 195         if (!variant.IsEmpty())
 196         {
 197                 pVariantStr = _StringConverter::CopyToCharArrayN(variant);
 198         }
 199
 200         IcuLocale icuLocale = IcuLocale(pLangStr, pCountryStr, pVariantStr);
 201
 202         delete[] pLangStr;
 203         delete[] pCountryStr;
 204         delete[] pVariantStr;
 205
 206         if (icuLocale.isBogus())
 207         {
 208                 SetLastResult(E_SYSTEM);
 209         }
 210
 211         return icuLocale;
 212 }
 213
 214
 215 const IcuLocale&
 216 _LocaleData::GetIcuLocale(void)
 217 {
 218         return __icuLocale;
 219 }
 220
 221 bool
 222 _LocaleData::IsLocaleSupported(void)
 223 {
 224         return !__icuLocale.isBogus();
 225 }
 226
 227 result
 228 _LocaleData::SetLocale(const Locale& ospLocale)
 229 {
 230         if (_LocaleImpl::IsSupported(ospLocale))
 231     {
 232         __icuLocale = GetIcuLocale(ospLocale);
 233         return E_SUCCESS;
 234     }
 235
 236         __icuLocale.setToBogus();
 237         return (Tizen::App::_AppInfo::GetApiVersion() == _API_VERSION_2_0 && Tizen::App::_AppInfo::IsOspCompat()) ? E_UNSUPPORTED_OPERATION : E_INVALID_ARG;
 238 }
 239
 240
 241 result
 242 _LocaleData::SetNumberFormatter(const Locale& locale, NumberFormatterStyle style)
 243 {
 244         if (__pIcuNumberFormatter)
 245         {
 246                 delete __pIcuNumberFormatter;
 247                 __pIcuNumberFormatter = null;
 248         }
 249
 250         IcuNumberFormat* pNumFmt = null;
 251         UErrorCode ec = U_ZERO_ERROR;
 252         result r = SetLocale(locale);
 253
 254         if (!IsFailed(r))
 255         {
 256                 switch (style)
 257                 {
 258                 case NUM_FORMATTER_STYLE_NUMBER:
 259                 {
 260                         pNumFmt = IcuNumberFormat::createInstance(__icuLocale, ec);
 261                         break;
 262                 }
 263
 264                 case NUM_FORMATTER_STYLE_CURRENCY:
 265                 {
 266                         pNumFmt = IcuNumberFormat::createCurrencyInstance(__icuLocale, ec);
 267                         break;
 268                 }
 269
 270                 case NUM_FORMATTER_STYLE_PERCENT:
 271                 {
 272                         pNumFmt = IcuNumberFormat::createPercentInstance(__icuLocale, ec);
 273                         break;
 274                 }
 275
 276                 default:
 277                 {
 278                         r = E_UNSUPPORTED_OPERATION;
 279                         break;
 280                 }
 281                 }
 282
 283                 if (IsFailed(r))
 284                 {
 285                         return r;
 286                 }
 287
 288                 if (U_SUCCESS(ec))
 289                 {
 290                         if (pNumFmt && (pNumFmt->getDynamicClassID() == IcuDecimalFormat::getStaticClassID()))
 291                         {
 292                                 __pIcuNumberFormatter = dynamic_cast< IcuDecimalFormat* >(pNumFmt);
 293                                 if (__pIcuNumberFormatter)
 294                                 {
 295                                         return E_SUCCESS;
 296                                 }
 297                         }
 298                 }
 299         }
 300
 301         return E_UNSUPPORTED_OPERATION;
 302 }
 303
 304 result
 305 _LocaleData::FormatNumber(long number, _FieldPosition& pos, Tizen::Base::String& str)
 306 {
 307         str = "";
 308
 309         if (__pIcuNumberFormatter)
 310         {
 311                 IcuUnicodeString icuStr;
 312                 IcuFieldPosition icuPos = GetIcuFieldPosition(pos);
 313                 icuStr = __pIcuNumberFormatter->format(static_cast< int32_t >(number), icuStr, icuPos);
 314
 315                 str = _LocaleData::GetOspString(icuStr);
 316                 return E_SUCCESS;
 317         }
 318
 319         return E_SYSTEM;
 320 }
 321
 322 result
 323 _LocaleData::FormatNumber(double number, _FieldPosition& pos, Tizen::Base::String& str)
 324 {
 325         str = "";
 326
 327         if (__pIcuNumberFormatter)
 328         {
 329                 IcuUnicodeString icuStr;
 330                 IcuFieldPosition icuPos = GetIcuFieldPosition(pos);
 331                 icuStr = __pIcuNumberFormatter->format(number, icuStr, icuPos);
 332
 333                 str = _LocaleData::GetOspString(icuStr);
 334                 return E_SUCCESS;
 335         }
 336
 337         return E_SYSTEM;
 338 }
 339
 340 result
 341 _LocaleData::ApplyNumberPattern(const Tizen::Base::String& pattern, bool localized)
 342 {
 343         if (__pIcuNumberFormatter)
 344         {
 345                 IcuUnicodeString icuPattern;
 346                 icuPattern = __pIcuNumberFormatter->toPattern(icuPattern);
 347
 348                 UErrorCode ec = U_ZERO_ERROR;
 349                 IcuUParseError parseError = {0,};
 350                 IcuUnicodeString icuNewPatter;
 351                 GetIcuString(pattern, icuNewPatter);
 352
 353                 if (localized)
 354                 {
 355                         __pIcuNumberFormatter->applyLocalizedPattern(icuNewPatter, parseError, ec);
 356                 }
 357                 else
 358                 {
 359                         __pIcuNumberFormatter->applyPattern(icuNewPatter, parseError, ec);
 360                 }
 361
 362                 if (U_SUCCESS(ec))
 363                 {
 364                         return E_SUCCESS;
 365                 }
 366                 else
 367                 {
 368                         SysLog(NID_LCL, "Error [%d -> %s] in setting pattern to %ls at %d:%d",
 369                                    ec, u_errorName(ec), pattern.GetPointer(), parseError.line, parseError.offset);
 370
 371                         __pIcuNumberFormatter->applyPattern(icuPattern, ec);
 372                 }
 373         }
 374
 375         return E_INVALID_ARG;
 376 }
 377
 378 String
 379 _LocaleData::GetNumberFormatterStringAttributes(NumberFormatterAttributes attrName)
 380 {
 381         IcuUnicodeString icuRetValue;
 382
 383         if (__pIcuNumberFormatter)
 384         {
 385                 switch (attrName)
 386                 {
 387                 case NUM_FORMATTER_FIELD_CURRENCY:
 388                 {
 389                         icuRetValue = __pIcuNumberFormatter->getCurrency();
 390                         break;
 391                 }
 392
 393                 case NUM_FORMATTER_FIELD_POSITIVE_PREFIX:
 394                 {
 395                         icuRetValue = __pIcuNumberFormatter->getPositivePrefix(icuRetValue);
 396                         break;
 397                 }
 398
 399                 case NUM_FORMATTER_FIELD_NEGATIVE_PREFIX:
 400                 {
 401                         icuRetValue = __pIcuNumberFormatter->getNegativePrefix(icuRetValue);
 402                         break;
 403                 }
 404
 405                 case NUM_FORMATTER_FIELD_POSITIVE_SUFFIX:
 406                 {
 407                         icuRetValue = __pIcuNumberFormatter->getPositiveSuffix(icuRetValue);
 408                         break;
 409                 }
 410
 411                 case NUM_FORMATTER_FIELD_NEGATIVE_SUFFIX:
 412                 {
 413                         icuRetValue = __pIcuNumberFormatter->getNegativeSuffix(icuRetValue);
 414                         break;
 415                 }
 416
 417                 case NUM_FORMATTER_FIELD_PATTERN:
 418                 {
 419                         icuRetValue = __pIcuNumberFormatter->toPattern(icuRetValue);
 420                         break;
 421                 }
 422
 423                 case NUM_FORMATTER_FIELD_LOCALIZED_PATTERN:
 424                 {
 425                         icuRetValue = __pIcuNumberFormatter->toLocalizedPattern(icuRetValue);
 426                         break;
 427                 }
 428
 429                 default:
 430                 {
 431                         break;
 432                 }
 433                 }
 434
 435                 return _LocaleData::GetOspString(icuRetValue);
 436         }
 437
 438         return Tizen::Base::String("");
 439 }
 440
 441 void
 442 _LocaleData::SetNumberFormatterAttributes(const String& newValue, NumberFormatterAttributes attrName)
 443 {
 444         if (__pIcuNumberFormatter)
 445         {
 446                 IcuUnicodeString icuNewValue;
 447                 GetIcuString(newValue, icuNewValue);
 448
 449                 switch (attrName)
 450                 {
 451                 case NUM_FORMATTER_FIELD_CURRENCY:
 452                 {
 453                         __pIcuNumberFormatter->setCurrency(icuNewValue.getTerminatedBuffer());
 454                         break;
 455                 }
 456
 457                 case NUM_FORMATTER_FIELD_POSITIVE_PREFIX:
 458                 {
 459                         __pIcuNumberFormatter->setPositivePrefix(icuNewValue);
 460                         break;
 461                 }
 462
 463                 case NUM_FORMATTER_FIELD_NEGATIVE_PREFIX:
 464                 {
 465                         __pIcuNumberFormatter->setNegativePrefix(icuNewValue);
 466                         break;
 467                 }
 468
 469                 case NUM_FORMATTER_FIELD_POSITIVE_SUFFIX:
 470                 {
 471                         __pIcuNumberFormatter->setPositiveSuffix(icuNewValue);
 472                         break;
 473                 }
 474
 475                 case NUM_FORMATTER_FIELD_NEGATIVE_SUFFIX:
 476                 {
 477                         __pIcuNumberFormatter->setNegativeSuffix(icuNewValue);
 478                         break;
 479                 }
 480
 481                 default:
 482                 {
 483                         break;
 484                 }
 485                 }
 486         }
 487 }
 488
 489 int
 490 _LocaleData::GetNumberFormatterIntAttributes(NumberFormatterAttributes attrName)
 491 {
 492         int res = 0;
 493         if (__pIcuNumberFormatter)
 494         {
 495                 switch (attrName)
 496                 {
 497                 case NUM_FORMATTER_FIELD_MAX_INTEGER_DIGITS:
 498                 {
 499                         res = __pIcuNumberFormatter->getMaximumIntegerDigits();
 500                         break;
 501                 }
 502
 503                 case NUM_FORMATTER_FIELD_MIN_INTEGER_DIGITS:
 504                 {
 505                         res = __pIcuNumberFormatter->getMinimumIntegerDigits();
 506                         break;
 507                 }
 508
 509                 case NUM_FORMATTER_FIELD_MAX_FRACTION_DIGITS:
 510                 {
 511                         res = __pIcuNumberFormatter->getMaximumFractionDigits();
 512                         break;
 513                 }
 514
 515                 case NUM_FORMATTER_FIELD_MIN_FRACTION_DIGITS:
 516                 {
 517                         res = __pIcuNumberFormatter->getMinimumFractionDigits();
 518                         break;
 519                 }
 520
 521                 case NUM_FORMATTER_FIELD_MIN_EXPONENT_DIGITS:
 522                 {
 523                         res = __pIcuNumberFormatter->getMinimumExponentDigits();
 524                         break;
 525                 }
 526
 527                 case NUM_FORMATTER_FIELD_MULTIPLIER:
 528                 {
 529                         res = __pIcuNumberFormatter->getMultiplier();
 530                         break;
 531                 }
 532
 533                 case NUM_FORMATTER_FIELD_GROUPING_SIZE:
 534                 {
 535                         res = __pIcuNumberFormatter->getGroupingSize();
 536                         break;
 537                 }
 538
 539                 default:
 540                 {
 541                         res = 0;
 542                         break;
 543                 }
 544                 }
 545         }
 546
 547         return res;
 548 }
 549
 550 void
 551 _LocaleData::SetNumberFormatterAttributes(const int newValue, NumberFormatterAttributes attrName)
 552 {
 553         if (__pIcuNumberFormatter)
 554         {
 555                 switch (attrName)
 556                 {
 557                 case NUM_FORMATTER_FIELD_MAX_INTEGER_DIGITS:
 558                 {
 559                         __pIcuNumberFormatter->setMaximumIntegerDigits(newValue);
 560                         break;
 561                 }
 562
 563                 case NUM_FORMATTER_FIELD_MIN_INTEGER_DIGITS:
 564                 {
 565                         __pIcuNumberFormatter->setMinimumIntegerDigits(newValue);
 566                         break;
 567                 }
 568
 569                 case NUM_FORMATTER_FIELD_MAX_FRACTION_DIGITS:
 570                 {
 571                         __pIcuNumberFormatter->setMaximumFractionDigits(newValue);
 572                         break;
 573                 }
 574
 575                 case NUM_FORMATTER_FIELD_MIN_FRACTION_DIGITS:
 576                 {
 577                         __pIcuNumberFormatter->setMinimumFractionDigits(newValue);
 578                         break;
 579                 }
 580
 581                 case NUM_FORMATTER_FIELD_MIN_EXPONENT_DIGITS:
 582                 {
 583                         __pIcuNumberFormatter->setMinimumExponentDigits(newValue);
 584                         break;
 585                 }
 586
 587                 case NUM_FORMATTER_FIELD_MULTIPLIER:
 588                 {
 589                         __pIcuNumberFormatter->setMultiplier(newValue);
 590                         break;
 591                 }
 592
 593                 case NUM_FORMATTER_FIELD_GROUPING_SIZE:
 594                 {
 595                         __pIcuNumberFormatter->setGroupingSize(newValue);
 596                         break;
 597                 }
 598
 599                 default:
 600                 {
 601                         break;
 602                 }
 603                 }
 604         }
 605 }
 606
 607 bool
 608 _LocaleData::GetNumberFormatterBoolAttributes(NumberFormatterAttributes attrName)
 609 {
 610         bool res = false;
 611         if (__pIcuNumberFormatter)
 612         {
 613                 switch (attrName)
 614                 {
 615                 case NUM_FORMATTER_FIELD_IS_GROUPING_USED:
 616                 {
 617                         res = __pIcuNumberFormatter->isGroupingUsed();
 618                         break;
 619                 }
 620
 621                 case NUM_FORMATTER_FIELD_IS_DECIMAL_SEPARATOR_ALWAYS_SHOWN:
 622                 {
 623                         res = __pIcuNumberFormatter->isDecimalSeparatorAlwaysShown();
 624                         break;
 625                 }
 626
 627                 case NUM_FORMATTER_FIELD_IS_POSITIVE_SIGN_ALWAYS_SHOWN:
 628                 {
 629                         IcuUnicodeString ps("+");
 630                         IcuUnicodeString pp;
 631                         pp = __pIcuNumberFormatter->getPositivePrefix(pp);
 632
 633                         res = (pp == ps);
 634                         break;
 635                 }
 636
 637                 default:
 638                 {
 639                         res = false;
 640                         break;
 641                 }
 642                 }
 643         }
 644
 645         return res;
 646 }
 647
 648 void
 649 _LocaleData::SetNumberFormatterAttributes(const bool newValue, NumberFormatterAttributes attrName)
 650 {
 651         if (__pIcuNumberFormatter)
 652         {
 653                 switch (attrName)
 654                 {
 655                 case NUM_FORMATTER_FIELD_IS_GROUPING_USED:
 656                 {
 657                         __pIcuNumberFormatter->setGroupingUsed(newValue);
 658                         break;
 659                 }
 660
 661                 case NUM_FORMATTER_FIELD_IS_DECIMAL_SEPARATOR_ALWAYS_SHOWN:
 662                 {
 663                         __pIcuNumberFormatter->setDecimalSeparatorAlwaysShown(newValue);
 664                         break;
 665                 }
 666
 667                 case NUM_FORMATTER_FIELD_IS_POSITIVE_SIGN_ALWAYS_SHOWN:
 668                 {
 669                         IcuUnicodeString ps("+");
 670                         IcuUnicodeString pp;
 671                         pp = __pIcuNumberFormatter->getPositivePrefix(pp);
 672
 673                         if (newValue)
 674                         {
 675                                 __pIcuNumberFormatter->setPositivePrefix(ps);
 676                         }
 677                         else
 678                         {
 679                                 if (pp == ps)
 680                                 {
 681                                         __pIcuNumberFormatter->setPositivePrefix("");
 682                                 }
 683                         }
 684                         break;
 685                 }
 686
 687                 default:
 688                 {
 689                         break;
 690                 }
 691                 }
 692         }
 693 }
 694
 695
 696 IcuUDate
 697 _LocaleData::GetIcuDate(DateTime date)
 698 {
 699         DateTime icuBaseTime;
 700         icuBaseTime.SetValue(1970, 1, 1);
 701         DateTime ospBaseTime = DateTime::GetMinValue();
 702
 703         result r = icuBaseTime.Subtract(ospBaseTime.GetTime());
 704         if (r != E_SUCCESS)
 705         {
 706                 SysLogException(NID_LCL, r, "[%s] Propagated.", GetErrorMessage(r));
 707         }
 708
 709         TimeSpan tsIcu = icuBaseTime.GetTime();
 710         TimeSpan tsOsp = date.GetTime();
 711         TimeSpan diff = tsOsp - tsIcu;
 712
 713         IcuUDate icuDate = diff.GetTicks();
 714         return icuDate;
 715 }
 716
 717 _LocaleData::_LocaleData(void)
 718         : __icuLocale()
 719         , __pIcuNumberFormatter(null)
 720 {
 721 }
 722
 723
 724 _LocaleData::~_LocaleData(void)
 725 {
 726         if (__pIcuNumberFormatter)                                                     // Delete __pIcuNumberFormatter and set to null
 727         {
 728                 delete __pIcuNumberFormatter;
 729                 __pIcuNumberFormatter = null;
 730         }
 731 }
 732
 733
 734 };
 735 };      // Tizen::Locales
 736