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 #include <unique_ptr.h>
  23 #include <unicode/decimfmt.h>
  24 #include <locale.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         setlocale(LC_ALL, "C");
 136         IcuUnicodeString icuStr;
 137         IcuFieldPosition icuPos = _LocaleData::GetIcuFieldPosition(pos);
 138         icuStr = __pIcuNumberFormatter->format(number, icuStr, icuPos);
 139         str = _LocaleData::GetOspString(icuStr);
 140         return E_SUCCESS;
 141 }
 142
 143 const Currency*
 144 _NumberFormatterImpl::GetCurrency(void)
 145 {
 146         return &__currency;
 147 }
 148
 149 void
 150 _NumberFormatterImpl::SetCurrency(const Currency& newValue)
 151 {
 152         __currency.Construct(newValue.GetCurrencyCode());
 153         __pIcuNumberFormatter->setCurrency(_LocaleData::GetIcuString(newValue.GetCurrencyCode()).getBuffer());
 154 }
 155
 156 int
 157 _NumberFormatterImpl::GetMaxIntegerDigits(void) const
 158 {
 159         return __pIcuNumberFormatter->getMaximumIntegerDigits();
 160 }
 161
 162 void
 163 _NumberFormatterImpl::SetMaxIntegerDigits(int newValue)
 164 {
 165         __pIcuNumberFormatter->setMaximumIntegerDigits(newValue);
 166 }
 167
 168 int
 169 _NumberFormatterImpl::GetMinIntegerDigits(void) const
 170 {
 171         return __pIcuNumberFormatter->getMinimumIntegerDigits();
 172 }
 173
 174 void
 175 _NumberFormatterImpl::SetMinIntegerDigits(int newValue)
 176 {
 177         __pIcuNumberFormatter->setMinimumIntegerDigits(newValue);
 178 }
 179
 180 int
 181 _NumberFormatterImpl::GetMaxFractionDigits(void) const
 182 {
 183         return __pIcuNumberFormatter->getMaximumFractionDigits();
 184 }
 185
 186 void
 187 _NumberFormatterImpl::SetMaxFractionDigits(int newValue)
 188 {
 189         __pIcuNumberFormatter->setMaximumFractionDigits(newValue);
 190 }
 191
 192 int
 193 _NumberFormatterImpl::GetMinFractionDigits(void) const
 194 {
 195         return __pIcuNumberFormatter->getMinimumFractionDigits();
 196 }
 197
 198 void
 199 _NumberFormatterImpl::SetMinFractionDigits(int newValue)
 200 {
 201         __pIcuNumberFormatter->setMinimumFractionDigits(newValue);
 202 }
 203
 204 bool
 205 _NumberFormatterImpl::IsGroupingUsed(void) const
 206 {
 207         return __pIcuNumberFormatter->isGroupingUsed();
 208 }
 209
 210 void
 211 _NumberFormatterImpl::SetGroupingUsed(bool newValue)
 212 {
 213         __pIcuNumberFormatter->setGroupingUsed(newValue);
 214 }
 215
 216 String
 217 _NumberFormatterImpl::GetPositivePrefix(void) const
 218 {
 219         IcuUnicodeString icuStr;
 220         return _LocaleData::GetOspString(__pIcuNumberFormatter->getPositivePrefix(icuStr));
 221 }
 222
 223 void
 224 _NumberFormatterImpl::SetPositivePrefix(const String& newValue)
 225 {
 226         __pIcuNumberFormatter->setPositivePrefix(_LocaleData::GetIcuString(newValue));
 227 }
 228
 229 String
 230 _NumberFormatterImpl::GetNegativePrefix(void) const
 231 {
 232         IcuUnicodeString icuStr;
 233         return _LocaleData::GetOspString(__pIcuNumberFormatter->getNegativePrefix(icuStr));
 234 }
 235
 236 void
 237 _NumberFormatterImpl::SetNegativePrefix(const String& newValue)
 238 {
 239         __pIcuNumberFormatter->setNegativePrefix(_LocaleData::GetIcuString(newValue));
 240 }
 241
 242 String
 243 _NumberFormatterImpl::GetPositiveSuffix(void) const
 244 {
 245         IcuUnicodeString icuStr;
 246         return _LocaleData::GetOspString(__pIcuNumberFormatter->getPositiveSuffix(icuStr));
 247 }
 248
 249 void
 250 _NumberFormatterImpl::SetPositiveSuffix(const String& newValue)
 251 {
 252         __pIcuNumberFormatter->setPositiveSuffix(_LocaleData::GetIcuString(newValue));
 253 }
 254
 255 String
 256 _NumberFormatterImpl::GetNegativeSuffix(void) const
 257 {
 258         IcuUnicodeString icuStr;
 259         return _LocaleData::GetOspString(__pIcuNumberFormatter->getNegativeSuffix(icuStr));
 260 }
 261
 262 void
 263 _NumberFormatterImpl::SetNegativeSuffix(const String& newValue)
 264 {
 265         __pIcuNumberFormatter->setNegativeSuffix(_LocaleData::GetIcuString(newValue));
 266 }
 267
 268 int
 269 _NumberFormatterImpl::GetMultiplier(void) const
 270 {
 271         return __pIcuNumberFormatter->getMultiplier();
 272 }
 273
 274 result
 275 _NumberFormatterImpl::SetMultiplier(int newValue)
 276 {
 277         __pIcuNumberFormatter->setMultiplier(newValue);
 278         return E_SUCCESS;
 279 }
 280
 281 int
 282 _NumberFormatterImpl::GetGroupingSize(void) const
 283 {
 284         return __pIcuNumberFormatter->getGroupingSize();
 285 }
 286
 287 result
 288 _NumberFormatterImpl::SetGroupingSize(int newValue)
 289 {
 290         __pIcuNumberFormatter->setGroupingSize(newValue);
 291         return E_SUCCESS;
 292 }
 293
 294 bool
 295 _NumberFormatterImpl::IsDecimalSeparatorAlwaysShown(void) const
 296 {
 297         return __pIcuNumberFormatter->isDecimalSeparatorAlwaysShown();
 298 }
 299
 300 void
 301 _NumberFormatterImpl::SetDecimalSeparatorAlwaysShown(bool newValue)
 302 {
 303         __pIcuNumberFormatter->setDecimalSeparatorAlwaysShown(newValue);
 304 }
 305
 306 bool
 307 _NumberFormatterImpl::IsPositiveSignAlwaysShown(void) const
 308 {
 309         IcuUnicodeString ps("+");
 310         IcuUnicodeString pp;
 311         pp = __pIcuNumberFormatter->getPositivePrefix(pp);
 312
 313         return (pp == ps);
 314 }
 315
 316 void
 317 _NumberFormatterImpl::SetPositiveSignAlwaysShown(bool newValue)
 318 {
 319         IcuUnicodeString ps("+");
 320         IcuUnicodeString pp;
 321         pp = __pIcuNumberFormatter->getPositivePrefix(pp);
 322
 323         if (newValue)
 324         {
 325                 __pIcuNumberFormatter->setPositivePrefix(ps);
 326         }
 327         else
 328         {
 329                 if (pp == ps)
 330                 {
 331                         __pIcuNumberFormatter->setPositivePrefix("");
 332                 }
 333         }
 334 }
 335
 336 } } // Tizen::Locales