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