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_NumberFormatterImpl.h"
  32
  33
  34 using namespace Tizen::Base;
  35
  36 namespace Tizen { namespace Locales
  37 {
  38
  39 _NumberFormatterImpl::_NumberFormatterImpl(void)
  40         : __pIcuNumberFormatter(null)
  41 {
  42 }
  43
  44 _NumberFormatterImpl::~_NumberFormatterImpl(void)
  45 {
  46         delete __pIcuNumberFormatter;
  47 }
  48
  49 NumberFormatter*
  50 _NumberFormatterImpl::CreateNumberFormatterN(NumberFormatterStyle style)
  51 {
  52         return CreateNumberFormatterN(_LocaleData::GetOspSystemLocale(), style);
  53 }
  54
  55 NumberFormatter*
  56 _NumberFormatterImpl::CreateNumberFormatterN(const Locale& locale, NumberFormatterStyle style)
  57 {
  58         IcuLocale icuLocale = _LocaleImpl::GetLocaleImpl(locale)->GetIcuLocale();
  59         SysTryReturn(NID_LCL, !icuLocale.isBogus(), null, E_UNSUPPORTED_OPERATION,
  60                                                 "[%s] Given locale is not supported", GetErrorMessage(E_UNSUPPORTED_OPERATION));
  61
  62         std::unique_ptr<NumberFormatter> pNewFormatter(new (std::nothrow) NumberFormatter);
  63         SysTryReturn(NID_LCL, pNewFormatter, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
  64
  65         std::unique_ptr<_NumberFormatterImpl> pNumberFormatterImpl(new (std::nothrow) _NumberFormatterImpl);
  66         SysTryReturn(NID_LCL, pNumberFormatterImpl, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed");
  67
  68         UNumberFormatStyle icuStyle = UNUM_FORMAT_STYLE_COUNT;
  69         switch(style)
  70         {
  71         case NUM_FORMATTER_STYLE_NUMBER:
  72                 icuStyle = UNUM_DECIMAL;
  73                 break;
  74         case NUM_FORMATTER_STYLE_CURRENCY:
  75                 icuStyle = UNUM_CURRENCY;
  76                 break;
  77         case NUM_FORMATTER_STYLE_PERCENT:
  78                 icuStyle = UNUM_PERCENT;
  79                 break;
  80         case NUM_FORMATTER_STYLE_INVALID:
  81                 break;
  82         }
  83
  84         UErrorCode ec = U_ZERO_ERROR;
  85         std::unique_ptr<IcuNumberFormat> pIcuNumberFormatter(IcuNumberFormat::createInstance(icuLocale, icuStyle, ec));
  86         if (pIcuNumberFormatter)
  87         {
  88                 IcuDecimalFormat* pDecimalFmt = dynamic_cast<IcuDecimalFormat*>(pIcuNumberFormatter.get());
  89                 if (pDecimalFmt)
  90                 {
  91                         pIcuNumberFormatter.release();
  92                         pNumberFormatterImpl->__pIcuNumberFormatter = pDecimalFmt;
  93                         pNumberFormatterImpl->__currency.Construct(locale);
  94                         pNewFormatter->__pNumberFormatterImpl = pNumberFormatterImpl.release();
  95
  96                         SetLastResult(E_SUCCESS);
  97                         return pNewFormatter.release();
  98                 }
  99         }
 100
 101         SetLastResult(E_INVALID_ARG);
 102         return null;
 103 }
 104
 105 result
 106 _NumberFormatterImpl::ApplyPattern(const String& pattern, bool localized)
 107 {
 108         UErrorCode ec = U_ZERO_ERROR;
 109         if (localized)
 110         {
 111                 __pIcuNumberFormatter->applyLocalizedPattern(_LocaleData::GetIcuString(pattern), ec);
 112         }
 113         else
 114         {
 115                 __pIcuNumberFormatter->applyPattern(_LocaleData::GetIcuString(pattern), ec);
 116         }
 117
 118         return U_SUCCESS(ec) ? E_SUCCESS : E_INVALID_ARG;
 119 }
 120
 121 result
 122 _NumberFormatterImpl::Format(long number, String& str, _FieldPosition pos) const
 123 {
 124         IcuUnicodeString icuStr;
 125         IcuFieldPosition icuPos = _LocaleData::GetIcuFieldPosition(pos);
 126         icuStr = __pIcuNumberFormatter->format((int64_t)number, icuStr, icuPos);
 127         str = _LocaleData::GetOspString(icuStr);
 128         return E_SUCCESS;
 129 }
 130
 131 result
 132 _NumberFormatterImpl::Format(double number, String& str, _FieldPosition pos) const
 133 {
 134         IcuUnicodeString icuStr;
 135         IcuFieldPosition icuPos = _LocaleData::GetIcuFieldPosition(pos);
 136         icuStr = __pIcuNumberFormatter->format(number, icuStr, icuPos);
 137         str = _LocaleData::GetOspString(icuStr);
 138         return E_SUCCESS;
 139 }
 140
 141 const Currency*
 142 _NumberFormatterImpl::GetCurrency(void)
 143 {
 144         return &__currency;
 145 }
 146
 147 void
 148 _NumberFormatterImpl::SetCurrency(const Currency& newValue)
 149 {
 150         __currency.Construct(newValue.GetCurrencyCode());
 151         __pIcuNumberFormatter->setCurrency(_LocaleData::GetIcuString(newValue.GetCurrencyCode()).getBuffer());
 152 }
 153
 154 int
 155 _NumberFormatterImpl::GetMaxIntegerDigits(void) const
 156 {
 157         return __pIcuNumberFormatter->getMaximumIntegerDigits();
 158 }
 159
 160 void
 161 _NumberFormatterImpl::SetMaxIntegerDigits(int newValue)
 162 {
 163         __pIcuNumberFormatter->setMaximumIntegerDigits(newValue);
 164 }
 165
 166 int
 167 _NumberFormatterImpl::GetMinIntegerDigits(void) const
 168 {
 169         return __pIcuNumberFormatter->getMinimumIntegerDigits();
 170 }
 171
 172 void
 173 _NumberFormatterImpl::SetMinIntegerDigits(int newValue)
 174 {
 175         __pIcuNumberFormatter->setMinimumIntegerDigits(newValue);
 176 }
 177
 178 int
 179 _NumberFormatterImpl::GetMaxFractionDigits(void) const
 180 {
 181         return __pIcuNumberFormatter->getMaximumFractionDigits();
 182 }
 183
 184 void
 185 _NumberFormatterImpl::SetMaxFractionDigits(int newValue)
 186 {
 187         __pIcuNumberFormatter->setMaximumFractionDigits(newValue);
 188 }
 189
 190 int
 191 _NumberFormatterImpl::GetMinFractionDigits(void) const
 192 {
 193         return __pIcuNumberFormatter->getMinimumFractionDigits();
 194 }
 195
 196 void
 197 _NumberFormatterImpl::SetMinFractionDigits(int newValue)
 198 {
 199         __pIcuNumberFormatter->setMinimumFractionDigits(newValue);
 200 }
 201
 202 bool
 203 _NumberFormatterImpl::IsGroupingUsed(void) const
 204 {
 205         return __pIcuNumberFormatter->isGroupingUsed();
 206 }
 207
 208 void
 209 _NumberFormatterImpl::SetGroupingUsed(bool newValue)
 210 {
 211         __pIcuNumberFormatter->setGroupingUsed(newValue);
 212 }
 213
 214 String
 215 _NumberFormatterImpl::GetPositivePrefix(void) const
 216 {
 217         IcuUnicodeString icuStr;
 218         return _LocaleData::GetOspString(__pIcuNumberFormatter->getPositivePrefix(icuStr));
 219 }
 220
 221 void
 222 _NumberFormatterImpl::SetPositivePrefix(const String& newValue)
 223 {
 224         __pIcuNumberFormatter->setPositivePrefix(_LocaleData::GetIcuString(newValue));
 225 }
 226
 227 String
 228 _NumberFormatterImpl::GetNegativePrefix(void) const
 229 {
 230         IcuUnicodeString icuStr;
 231         return _LocaleData::GetOspString(__pIcuNumberFormatter->getNegativePrefix(icuStr));
 232 }
 233
 234 void
 235 _NumberFormatterImpl::SetNegativePrefix(const String& newValue)
 236 {
 237         __pIcuNumberFormatter->setNegativePrefix(_LocaleData::GetIcuString(newValue));
 238 }
 239
 240 String
 241 _NumberFormatterImpl::GetPositiveSuffix(void) const
 242 {
 243         IcuUnicodeString icuStr;
 244         return _LocaleData::GetOspString(__pIcuNumberFormatter->getPositiveSuffix(icuStr));
 245 }
 246
 247 void
 248 _NumberFormatterImpl::SetPositiveSuffix(const String& newValue)
 249 {
 250         __pIcuNumberFormatter->setPositiveSuffix(_LocaleData::GetIcuString(newValue));
 251 }
 252
 253 String
 254 _NumberFormatterImpl::GetNegativeSuffix(void) const
 255 {
 256         IcuUnicodeString icuStr;
 257         return _LocaleData::GetOspString(__pIcuNumberFormatter->getNegativeSuffix(icuStr));
 258 }
 259
 260 void
 261 _NumberFormatterImpl::SetNegativeSuffix(const String& newValue)
 262 {
 263         __pIcuNumberFormatter->setNegativeSuffix(_LocaleData::GetIcuString(newValue));
 264 }
 265
 266 int
 267 _NumberFormatterImpl::GetMultiplier(void) const
 268 {
 269         return __pIcuNumberFormatter->getMultiplier();
 270 }
 271
 272 result
 273 _NumberFormatterImpl::SetMultiplier(int newValue)
 274 {
 275         __pIcuNumberFormatter->setMultiplier(newValue);
 276         return E_SUCCESS;
 277 }
 278
 279 int
 280 _NumberFormatterImpl::GetGroupingSize(void) const
 281 {
 282         return __pIcuNumberFormatter->getGroupingSize();
 283 }
 284
 285 result
 286 _NumberFormatterImpl::SetGroupingSize(int newValue)
 287 {
 288         __pIcuNumberFormatter->setGroupingSize(newValue);
 289         return E_SUCCESS;
 290 }
 291
 292 bool
 293 _NumberFormatterImpl::IsDecimalSeparatorAlwaysShown(void) const
 294 {
 295         return __pIcuNumberFormatter->isDecimalSeparatorAlwaysShown();
 296 }
 297
 298 void
 299 _NumberFormatterImpl::SetDecimalSeparatorAlwaysShown(bool newValue)
 300 {
 301         __pIcuNumberFormatter->setDecimalSeparatorAlwaysShown(newValue);
 302 }
 303
 304 bool
 305 _NumberFormatterImpl::IsPositiveSignAlwaysShown(void) const
 306 {
 307         IcuUnicodeString ps("+");
 308         IcuUnicodeString pp;
 309         pp = __pIcuNumberFormatter->getPositivePrefix(pp);
 310
 311         return (pp == ps);
 312 }
 313
 314 void
 315 _NumberFormatterImpl::SetPositiveSignAlwaysShown(bool newValue)
 316 {
 317         IcuUnicodeString ps("+");
 318         IcuUnicodeString pp;
 319         pp = __pIcuNumberFormatter->getPositivePrefix(pp);
 320
 321         if (newValue)
 322         {
 323                 __pIcuNumberFormatter->setPositivePrefix(ps);
 324         }
 325         else
 326         {
 327                 if (pp == ps)
 328                 {
 329                         __pIcuNumberFormatter->setPositivePrefix("");
 330                 }
 331         }
 332 }
 333
 334 } } // Tizen::Locales