src/locales/FLcl_NumberFormatterImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file        FLclNumberFormatterEx.cpp
  20  * @brief       This is the implementation file for the NumberFormatterEx class.
  21  */
  22
  23 #include <unique_ptr.h>
  24 #include <unicode/decimfmt.h>
  25
  26 #include <FBaseSysLog.h>
  27 #include <FLclNumberFormatter.h>
  28
  29 #include "FLcl_LocaleData.h"
  30 #include "FLcl_LocaleImpl.h"
  31 #include "FLcl_LocaleManagerImpl.h"
  32 #include "FLcl_NumberFormatterImpl.h"
  33
  34
  35 using namespace Tizen::Base;
  36
  37 namespace Tizen { namespace Locales
  38 {
  39
  40 _NumberFormatterImpl::_NumberFormatterImpl(void)
  41         : __pIcuNumberFormatter(null)
  42 {
  43 }
  44
  45 _NumberFormatterImpl::~_NumberFormatterImpl(void)
  46 {
  47         delete __pIcuNumberFormatter;
  48 }
  49
  50 NumberFormatter*
  51 _NumberFormatterImpl::CreateNumberFormatterN(NumberFormatterStyle style)
  52 {
  53         return CreateNumberFormatterN(_LocaleManagerImpl::GetSystemLocale(), style);
  54 }
  55
  56 NumberFormatter*
  57 _NumberFormatterImpl::CreateNumberFormatterN(const Locale& locale, NumberFormatterStyle style)
  58 {
  59         IcuLocale icuLocale = _LocaleImpl::GetLocaleImpl(locale)->GetIcuLocale();
  60         SysTryReturn(NID_LCL, !icuLocale.isBogus(), null, E_UNSUPPORTED_OPERATION,
  61                                                 "[%s] Given locale is not supported", GetErrorMessage(E_UNSUPPORTED_OPERATION));
  62
  63         std::unique_ptr<NumberFormatter> pNewFormatter(new (std::nothrow) NumberFormatter);
  64         SysTryReturn(NID_LCL, pNewFormatter, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
  65
  66         std::unique_ptr<_NumberFormatterImpl> pNumberFormatterImpl(new (std::nothrow) _NumberFormatterImpl);
  67         SysTryReturn(NID_LCL, pNumberFormatterImpl, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed");
  68
  69         UNumberFormatStyle icuStyle = UNUM_FORMAT_STYLE_COUNT;
  70         switch(style)
  71         {
  72         case NUM_FORMATTER_STYLE_NUMBER:
  73                 icuStyle = UNUM_DECIMAL;
  74                 break;
  75         case NUM_FORMATTER_STYLE_CURRENCY:
  76                 icuStyle = UNUM_CURRENCY;
  77                 break;
  78         case NUM_FORMATTER_STYLE_PERCENT:
  79                 icuStyle = UNUM_PERCENT;
  80                 break;
  81         case NUM_FORMATTER_STYLE_INVALID:
  82                 break;
  83         }
  84
  85         UErrorCode ec = U_ZERO_ERROR;
  86         std::unique_ptr<IcuNumberFormat> pIcuNumberFormatter(IcuNumberFormat::createInstance(icuLocale, icuStyle, ec));
  87         if (pIcuNumberFormatter)
  88         {
  89                 IcuDecimalFormat* pDecimalFmt = dynamic_cast<IcuDecimalFormat*>(pIcuNumberFormatter.get());
  90                 if (pDecimalFmt)
  91                 {
  92                         pIcuNumberFormatter.release();
  93                         pNumberFormatterImpl->__pIcuNumberFormatter = pDecimalFmt;
  94                         pNumberFormatterImpl->__currency.Construct(locale);
  95                         pNewFormatter->__pNumberFormatterImpl = pNumberFormatterImpl.release();
  96
  97                         SetLastResult(E_SUCCESS);
  98                         return pNewFormatter.release();
  99                 }
 100         }
 101
 102         SetLastResult(E_INVALID_ARG);
 103         return null;
 104 }
 105
 106 result
 107 _NumberFormatterImpl::ApplyPattern(const String& pattern, bool localized)
 108 {
 109         UErrorCode ec = U_ZERO_ERROR;
 110         if (localized)
 111         {
 112                 __pIcuNumberFormatter->applyLocalizedPattern(_LocaleData::GetIcuString(pattern), ec);
 113         }
 114         else
 115         {
 116                 __pIcuNumberFormatter->applyPattern(_LocaleData::GetIcuString(pattern), ec);
 117         }
 118
 119         return U_SUCCESS(ec) ? E_SUCCESS : E_INVALID_ARG;
 120 }
 121
 122 result
 123 _NumberFormatterImpl::Format(long number, String& str, _FieldPosition pos) const
 124 {
 125         IcuUnicodeString icuStr;
 126         IcuFieldPosition icuPos = _LocaleData::GetIcuFieldPosition(pos);
 127         icuStr = __pIcuNumberFormatter->format((int64_t)number, icuStr, icuPos);
 128         str = _LocaleData::GetOspString(icuStr);
 129         return E_SUCCESS;
 130 }
 131
 132 result
 133 _NumberFormatterImpl::Format(double number, String& str, _FieldPosition pos) const
 134 {
 135         IcuUnicodeString icuStr;
 136         IcuFieldPosition icuPos = _LocaleData::GetIcuFieldPosition(pos);
 137         icuStr = __pIcuNumberFormatter->format(number, icuStr, icuPos);
 138         str = _LocaleData::GetOspString(icuStr);
 139         return E_SUCCESS;
 140 }
 141
 142 const Currency*
 143 _NumberFormatterImpl::GetCurrency(void)
 144 {
 145         return &__currency;
 146 }
 147
 148 void
 149 _NumberFormatterImpl::SetCurrency(const Currency& newValue)
 150 {
 151         __currency.Construct(newValue.GetCurrencyCode());
 152         __pIcuNumberFormatter->setCurrency(_LocaleData::GetIcuString(newValue.GetCurrencyCode()).getBuffer());
 153 }
 154
 155 int
 156 _NumberFormatterImpl::GetMaxIntegerDigits(void) const
 157 {
 158         return __pIcuNumberFormatter->getMaximumIntegerDigits();
 159 }
 160
 161 void
 162 _NumberFormatterImpl::SetMaxIntegerDigits(int newValue)
 163 {
 164         __pIcuNumberFormatter->setMaximumIntegerDigits(newValue);
 165 }
 166
 167 int
 168 _NumberFormatterImpl::GetMinIntegerDigits(void) const
 169 {
 170         return __pIcuNumberFormatter->getMinimumIntegerDigits();
 171 }
 172
 173 void
 174 _NumberFormatterImpl::SetMinIntegerDigits(int newValue)
 175 {
 176         __pIcuNumberFormatter->setMinimumIntegerDigits(newValue);
 177 }
 178
 179 int
 180 _NumberFormatterImpl::GetMaxFractionDigits(void) const
 181 {
 182         return __pIcuNumberFormatter->getMaximumFractionDigits();
 183 }
 184
 185 void
 186 _NumberFormatterImpl::SetMaxFractionDigits(int newValue)
 187 {
 188         __pIcuNumberFormatter->setMaximumFractionDigits(newValue);
 189 }
 190
 191 int
 192 _NumberFormatterImpl::GetMinFractionDigits(void) const
 193 {
 194         return __pIcuNumberFormatter->getMinimumFractionDigits();
 195 }
 196
 197 void
 198 _NumberFormatterImpl::SetMinFractionDigits(int newValue)
 199 {
 200         __pIcuNumberFormatter->setMinimumFractionDigits(newValue);
 201 }
 202
 203 bool
 204 _NumberFormatterImpl::IsGroupingUsed(void) const
 205 {
 206         return __pIcuNumberFormatter->isGroupingUsed();
 207 }
 208
 209 void
 210 _NumberFormatterImpl::SetGroupingUsed(bool newValue)
 211 {
 212         __pIcuNumberFormatter->setGroupingUsed(newValue);
 213 }
 214
 215 String
 216 _NumberFormatterImpl::GetPositivePrefix(void) const
 217 {
 218         IcuUnicodeString icuStr;
 219         return _LocaleData::GetOspString(__pIcuNumberFormatter->getPositivePrefix(icuStr));
 220 }
 221
 222 void
 223 _NumberFormatterImpl::SetPositivePrefix(const String& newValue)
 224 {
 225         __pIcuNumberFormatter->setPositivePrefix(_LocaleData::GetIcuString(newValue));
 226 }
 227
 228 String
 229 _NumberFormatterImpl::GetNegativePrefix(void) const
 230 {
 231         IcuUnicodeString icuStr;
 232         return _LocaleData::GetOspString(__pIcuNumberFormatter->getNegativePrefix(icuStr));
 233 }
 234
 235 void
 236 _NumberFormatterImpl::SetNegativePrefix(const String& newValue)
 237 {
 238         __pIcuNumberFormatter->setNegativePrefix(_LocaleData::GetIcuString(newValue));
 239 }
 240
 241 String
 242 _NumberFormatterImpl::GetPositiveSuffix(void) const
 243 {
 244         IcuUnicodeString icuStr;
 245         return _LocaleData::GetOspString(__pIcuNumberFormatter->getPositiveSuffix(icuStr));
 246 }
 247
 248 void
 249 _NumberFormatterImpl::SetPositiveSuffix(const String& newValue)
 250 {
 251         __pIcuNumberFormatter->setPositiveSuffix(_LocaleData::GetIcuString(newValue));
 252 }
 253
 254 String
 255 _NumberFormatterImpl::GetNegativeSuffix(void) const
 256 {
 257         IcuUnicodeString icuStr;
 258         return _LocaleData::GetOspString(__pIcuNumberFormatter->getNegativeSuffix(icuStr));
 259 }
 260
 261 void
 262 _NumberFormatterImpl::SetNegativeSuffix(const String& newValue)
 263 {
 264         __pIcuNumberFormatter->setNegativeSuffix(_LocaleData::GetIcuString(newValue));
 265 }
 266
 267 int
 268 _NumberFormatterImpl::GetMultiplier(void) const
 269 {
 270         return __pIcuNumberFormatter->getMultiplier();
 271 }
 272
 273 result
 274 _NumberFormatterImpl::SetMultiplier(int newValue)
 275 {
 276         __pIcuNumberFormatter->setMultiplier(newValue);
 277         return E_SUCCESS;
 278 }
 279
 280 int
 281 _NumberFormatterImpl::GetGroupingSize(void) const
 282 {
 283         return __pIcuNumberFormatter->getGroupingSize();
 284 }
 285
 286 result
 287 _NumberFormatterImpl::SetGroupingSize(int newValue)
 288 {
 289         __pIcuNumberFormatter->setGroupingSize(newValue);
 290         return E_SUCCESS;
 291 }
 292
 293 bool
 294 _NumberFormatterImpl::IsDecimalSeparatorAlwaysShown(void) const
 295 {
 296         return __pIcuNumberFormatter->isDecimalSeparatorAlwaysShown();
 297 }
 298
 299 void
 300 _NumberFormatterImpl::SetDecimalSeparatorAlwaysShown(bool newValue)
 301 {
 302         __pIcuNumberFormatter->setDecimalSeparatorAlwaysShown(newValue);
 303 }
 304
 305 bool
 306 _NumberFormatterImpl::IsPositiveSignAlwaysShown(void) const
 307 {
 308         IcuUnicodeString ps("+");
 309         IcuUnicodeString pp;
 310         pp = __pIcuNumberFormatter->getPositivePrefix(pp);
 311
 312         return (pp == ps);
 313 }
 314
 315 void
 316 _NumberFormatterImpl::SetPositiveSignAlwaysShown(bool newValue)
 317 {
 318         IcuUnicodeString ps("+");
 319         IcuUnicodeString pp;
 320         pp = __pIcuNumberFormatter->getPositivePrefix(pp);
 321
 322         if (newValue)
 323         {
 324                 __pIcuNumberFormatter->setPositivePrefix(ps);
 325         }
 326         else
 327         {
 328                 if (pp == ps)
 329                 {
 330                         __pIcuNumberFormatter->setPositivePrefix("");
 331                 }
 332         }
 333 }
 334
 335 } } // Tizen::Locales