icuSources/i18n/unum.cpp

   1 /*
   2 *******************************************************************************
   3 *   Copyright (C) 1996-2012, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 *******************************************************************************
   6 * Modification History:
   7 *
   8 *   Date        Name        Description
   9 *   06/24/99    helena      Integrated Alan's NF enhancements and Java2 bug fixes
  10 *******************************************************************************
  11 */
  12
  13 #include "unicode/utypes.h"
  14
  15 #if !UCONFIG_NO_FORMATTING
  16
  17 #include "unicode/unum.h"
  18
  19 #include "unicode/uloc.h"
  20 #include "unicode/numfmt.h"
  21 #include "unicode/decimfmt.h"
  22 #include "unicode/rbnf.h"
  23 #include "unicode/ustring.h"
  24 #include "unicode/fmtable.h"
  25 #include "unicode/dcfmtsym.h"
  26 #include "unicode/curramt.h"
  27 #include "unicode/localpointer.h"
  28 #include "uassert.h"
  29 #include "cpputils.h"
  30 #include "cstring.h"
  31
  32
  33 U_NAMESPACE_USE
  34
  35
  36 U_CAPI UNumberFormat* U_EXPORT2
  37 unum_open(  UNumberFormatStyle    style,
  38             const    UChar*    pattern,
  39             int32_t            patternLength,
  40             const    char*     locale,
  41             UParseError*       parseErr,
  42             UErrorCode*        status) {
  43     if(U_FAILURE(*status)) {
  44         return NULL;
  45     }
  46
  47     NumberFormat *retVal = NULL;
  48
  49     switch(style) {
  50     case UNUM_DECIMAL:
  51     case UNUM_CURRENCY:
  52     case UNUM_PERCENT:
  53     case UNUM_SCIENTIFIC:
  54         retVal = NumberFormat::createInstance(Locale(locale), style, *status);
  55         break;
  56
  57     case UNUM_PATTERN_DECIMAL: {
  58         UParseError tErr;
  59         /* UnicodeString can handle the case when patternLength = -1. */
  60         const UnicodeString pat(pattern, patternLength);
  61
  62         if(parseErr==NULL){
  63             parseErr = &tErr;
  64         }
  65
  66         DecimalFormatSymbols *syms = new DecimalFormatSymbols(Locale(locale), *status);
  67         if(syms == NULL) {
  68             *status = U_MEMORY_ALLOCATION_ERROR;
  69             return NULL;
  70         }
  71         if (U_FAILURE(*status)) {
  72             delete syms;
  73             return NULL;
  74         }
  75
  76         retVal = new DecimalFormat(pat, syms, *parseErr, *status);
  77         if(retVal == NULL) {
  78             delete syms;
  79         }
  80     } break;
  81
  82 #if U_HAVE_RBNF
  83     case UNUM_PATTERN_RULEBASED: {
  84         UParseError tErr;
  85         /* UnicodeString can handle the case when patternLength = -1. */
  86         const UnicodeString pat(pattern, patternLength);
  87
  88         if(parseErr==NULL){
  89             parseErr = &tErr;
  90         }
  91
  92         retVal = new RuleBasedNumberFormat(pat, Locale(locale), *parseErr, *status);
  93     } break;
  94
  95     case UNUM_SPELLOUT:
  96         retVal = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale(locale), *status);
  97         break;
  98
  99     case UNUM_ORDINAL:
 100         retVal = new RuleBasedNumberFormat(URBNF_ORDINAL, Locale(locale), *status);
 101         break;
 102
 103     case UNUM_DURATION:
 104         retVal = new RuleBasedNumberFormat(URBNF_DURATION, Locale(locale), *status);
 105         break;
 106
 107     case UNUM_NUMBERING_SYSTEM:
 108         retVal = new RuleBasedNumberFormat(URBNF_NUMBERING_SYSTEM, Locale(locale), *status);
 109         break;
 110 #endif
 111
 112     default:
 113         *status = U_UNSUPPORTED_ERROR;
 114         return NULL;
 115     }
 116
 117     if(retVal == NULL && U_SUCCESS(*status)) {
 118         *status = U_MEMORY_ALLOCATION_ERROR;
 119     }
 120
 121     return reinterpret_cast<UNumberFormat *>(retVal);
 122 }
 123
 124 U_CAPI void U_EXPORT2
 125 unum_close(UNumberFormat* fmt)
 126 {
 127     delete (NumberFormat*) fmt;
 128 }
 129
 130 U_CAPI UNumberFormat* U_EXPORT2
 131 unum_clone(const UNumberFormat *fmt,
 132        UErrorCode *status)
 133 {
 134     if(U_FAILURE(*status))
 135         return 0;
 136
 137     Format *res = 0;
 138     const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
 139     const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
 140     if (df != NULL) {
 141         res = df->clone();
 142     } else {
 143         const RuleBasedNumberFormat* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(nf);
 144         U_ASSERT(rbnf != NULL);
 145         res = rbnf->clone();
 146     }
 147
 148     if(res == 0) {
 149         *status = U_MEMORY_ALLOCATION_ERROR;
 150         return 0;
 151     }
 152
 153     return (UNumberFormat*) res;
 154 }
 155
 156 U_CAPI int32_t U_EXPORT2
 157 unum_format(    const    UNumberFormat*    fmt,
 158         int32_t           number,
 159         UChar*            result,
 160         int32_t           resultLength,
 161         UFieldPosition    *pos,
 162         UErrorCode*       status)
 163 {
 164         return unum_formatInt64(fmt, number, result, resultLength, pos, status);
 165 }
 166
 167 U_CAPI int32_t U_EXPORT2
 168 unum_formatInt64(const UNumberFormat* fmt,
 169         int64_t         number,
 170         UChar*          result,
 171         int32_t         resultLength,
 172         UFieldPosition *pos,
 173         UErrorCode*     status)
 174 {
 175     if(U_FAILURE(*status))
 176         return -1;
 177
 178     UnicodeString res;
 179     if(!(result==NULL && resultLength==0)) {
 180         // NULL destination for pure preflighting: empty dummy string
 181         // otherwise, alias the destination buffer
 182         res.setTo(result, 0, resultLength);
 183     }
 184
 185     FieldPosition fp;
 186
 187     if(pos != 0)
 188         fp.setField(pos->field);
 189
 190     ((const NumberFormat*)fmt)->format(number, res, fp, *status);
 191
 192     if(pos != 0) {
 193         pos->beginIndex = fp.getBeginIndex();
 194         pos->endIndex = fp.getEndIndex();
 195     }
 196
 197     return res.extract(result, resultLength, *status);
 198 }
 199
 200 U_CAPI int32_t U_EXPORT2
 201 unum_formatDouble(    const    UNumberFormat*  fmt,
 202             double          number,
 203             UChar*          result,
 204             int32_t         resultLength,
 205             UFieldPosition  *pos, /* 0 if ignore */
 206             UErrorCode*     status)
 207 {
 208
 209   if(U_FAILURE(*status)) return -1;
 210
 211   UnicodeString res;
 212   if(!(result==NULL && resultLength==0)) {
 213     // NULL destination for pure preflighting: empty dummy string
 214     // otherwise, alias the destination buffer
 215     res.setTo(result, 0, resultLength);
 216   }
 217
 218   FieldPosition fp;
 219
 220   if(pos != 0)
 221     fp.setField(pos->field);
 222
 223   ((const NumberFormat*)fmt)->format(number, res, fp, *status);
 224
 225   if(pos != 0) {
 226     pos->beginIndex = fp.getBeginIndex();
 227     pos->endIndex = fp.getEndIndex();
 228   }
 229
 230   return res.extract(result, resultLength, *status);
 231 }
 232
 233
 234 U_CAPI int32_t U_EXPORT2
 235 unum_formatDecimal(const    UNumberFormat*  fmt,
 236             const char *    number,
 237             int32_t         length,
 238             UChar*          result,
 239             int32_t         resultLength,
 240             UFieldPosition  *pos, /* 0 if ignore */
 241             UErrorCode*     status) {
 242
 243     if(U_FAILURE(*status)) {
 244         return -1;
 245     }
 246     if ((result == NULL && resultLength != 0) || resultLength < 0) {
 247         *status = U_ILLEGAL_ARGUMENT_ERROR;
 248         return -1;
 249     }
 250
 251     FieldPosition fp;
 252     if(pos != 0) {
 253         fp.setField(pos->field);
 254     }
 255
 256     if (length < 0) {
 257         length = uprv_strlen(number);
 258     }
 259     StringPiece numSP(number, length);
 260     Formattable numFmtbl(numSP, *status);
 261
 262     UnicodeString resultStr;
 263     if (resultLength > 0) {
 264         // Alias the destination buffer.
 265         resultStr.setTo(result, 0, resultLength);
 266     }
 267     ((const NumberFormat*)fmt)->format(numFmtbl, resultStr, fp, *status);
 268     if(pos != 0) {
 269         pos->beginIndex = fp.getBeginIndex();
 270         pos->endIndex = fp.getEndIndex();
 271     }
 272     return resultStr.extract(result, resultLength, *status);
 273 }
 274
 275
 276
 277
 278 U_CAPI int32_t U_EXPORT2
 279 unum_formatDoubleCurrency(const UNumberFormat* fmt,
 280                           double number,
 281                           UChar* currency,
 282                           UChar* result,
 283                           int32_t resultLength,
 284                           UFieldPosition* pos, /* ignored if 0 */
 285                           UErrorCode* status) {
 286     if (U_FAILURE(*status)) return -1;
 287
 288     UnicodeString res;
 289     if (!(result==NULL && resultLength==0)) {
 290         // NULL destination for pure preflighting: empty dummy string
 291         // otherwise, alias the destination buffer
 292         res.setTo(result, 0, resultLength);
 293     }
 294
 295     FieldPosition fp;
 296     if (pos != 0) {
 297         fp.setField(pos->field);
 298     }
 299     CurrencyAmount *tempCurrAmnt = new CurrencyAmount(number, currency, *status);
 300     // Check for null pointer.
 301     if (tempCurrAmnt == NULL) {
 302         *status = U_MEMORY_ALLOCATION_ERROR;
 303         return -1;
 304     }
 305     Formattable n(tempCurrAmnt);
 306     ((const NumberFormat*)fmt)->format(n, res, fp, *status);
 307
 308     if (pos != 0) {
 309         pos->beginIndex = fp.getBeginIndex();
 310         pos->endIndex = fp.getEndIndex();
 311     }
 312
 313     return res.extract(result, resultLength, *status);
 314 }
 315
 316 static void
 317 parseRes(Formattable& res,
 318          const   UNumberFormat*  fmt,
 319          const   UChar*          text,
 320          int32_t         textLength,
 321          int32_t         *parsePos /* 0 = start */,
 322          UErrorCode      *status)
 323 {
 324     if(U_FAILURE(*status))
 325         return;
 326
 327     const UnicodeString src((UBool)(textLength == -1), text, textLength);
 328     ParsePosition pp;
 329
 330     if(parsePos != 0)
 331         pp.setIndex(*parsePos);
 332
 333     ((const NumberFormat*)fmt)->parse(src, res, pp);
 334
 335     if(pp.getErrorIndex() != -1) {
 336         *status = U_PARSE_ERROR;
 337         if(parsePos != 0) {
 338             *parsePos = pp.getErrorIndex();
 339         }
 340     } else if(parsePos != 0) {
 341         *parsePos = pp.getIndex();
 342     }
 343 }
 344
 345 U_CAPI int32_t U_EXPORT2
 346 unum_parse(    const   UNumberFormat*  fmt,
 347         const   UChar*          text,
 348         int32_t         textLength,
 349         int32_t         *parsePos /* 0 = start */,
 350         UErrorCode      *status)
 351 {
 352     Formattable res;
 353     parseRes(res, fmt, text, textLength, parsePos, status);
 354     return res.getLong(*status);
 355 }
 356
 357 U_CAPI int64_t U_EXPORT2
 358 unum_parseInt64(    const   UNumberFormat*  fmt,
 359         const   UChar*          text,
 360         int32_t         textLength,
 361         int32_t         *parsePos /* 0 = start */,
 362         UErrorCode      *status)
 363 {
 364     Formattable res;
 365     parseRes(res, fmt, text, textLength, parsePos, status);
 366     return res.getInt64(*status);
 367 }
 368
 369 U_CAPI double U_EXPORT2
 370 unum_parseDouble(    const   UNumberFormat*  fmt,
 371             const   UChar*          text,
 372             int32_t         textLength,
 373             int32_t         *parsePos /* 0 = start */,
 374             UErrorCode      *status)
 375 {
 376     Formattable res;
 377     parseRes(res, fmt, text, textLength, parsePos, status);
 378     return res.getDouble(*status);
 379 }
 380
 381 U_CAPI int32_t U_EXPORT2
 382 unum_parseDecimal(const UNumberFormat*  fmt,
 383             const UChar*    text,
 384             int32_t         textLength,
 385             int32_t         *parsePos /* 0 = start */,
 386             char            *outBuf,
 387             int32_t         outBufLength,
 388             UErrorCode      *status)
 389 {
 390     if (U_FAILURE(*status)) {
 391         return -1;
 392     }
 393     if ((outBuf == NULL && outBufLength != 0) || outBufLength < 0) {
 394         *status = U_ILLEGAL_ARGUMENT_ERROR;
 395         return -1;
 396     }
 397     Formattable res;
 398     parseRes(res, fmt, text, textLength, parsePos, status);
 399     StringPiece sp = res.getDecimalNumber(*status);
 400     if (U_FAILURE(*status)) {
 401        return -1;
 402     } else if (sp.size() > outBufLength) {
 403         *status = U_BUFFER_OVERFLOW_ERROR;
 404     } else if (sp.size() == outBufLength) {
 405         uprv_strncpy(outBuf, sp.data(), sp.size());
 406         *status = U_STRING_NOT_TERMINATED_WARNING;
 407     } else {
 408         U_ASSERT(outBufLength > 0);
 409         uprv_strcpy(outBuf, sp.data());
 410     }
 411     return sp.size();
 412 }
 413
 414 U_CAPI double U_EXPORT2
 415 unum_parseDoubleCurrency(const UNumberFormat* fmt,
 416                          const UChar* text,
 417                          int32_t textLength,
 418                          int32_t* parsePos, /* 0 = start */
 419                          UChar* currency,
 420                          UErrorCode* status) {
 421     double doubleVal = 0.0;
 422     currency[0] = 0;
 423     if (U_FAILURE(*status)) {
 424         return doubleVal;
 425     }
 426     const UnicodeString src((UBool)(textLength == -1), text, textLength);
 427     ParsePosition pp;
 428     if (parsePos != NULL) {
 429         pp.setIndex(*parsePos);
 430     }
 431     *status = U_PARSE_ERROR; // assume failure, reset if succeed
 432     LocalPointer<CurrencyAmount> currAmt(((const NumberFormat*)fmt)->parseCurrency(src, pp));
 433     if (pp.getErrorIndex() != -1) {
 434         if (parsePos != NULL) {
 435             *parsePos = pp.getErrorIndex();
 436         }
 437     } else {
 438         if (parsePos != NULL) {
 439             *parsePos = pp.getIndex();
 440         }
 441         if (pp.getIndex() > 0) {
 442             *status = U_ZERO_ERROR;
 443             u_strcpy(currency, currAmt->getISOCurrency());
 444             doubleVal = currAmt->getNumber().getDouble(*status);
 445         }
 446     }
 447     return doubleVal;
 448 }
 449
 450 U_CAPI const char* U_EXPORT2
 451 unum_getAvailable(int32_t index)
 452 {
 453     return uloc_getAvailable(index);
 454 }
 455
 456 U_CAPI int32_t U_EXPORT2
 457 unum_countAvailable()
 458 {
 459     return uloc_countAvailable();
 460 }
 461
 462 U_CAPI int32_t U_EXPORT2
 463 unum_getAttribute(const UNumberFormat*          fmt,
 464           UNumberFormatAttribute  attr)
 465 {
 466   const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
 467   if ( attr == UNUM_LENIENT_PARSE ) {
 468     // Supported for all subclasses
 469     return nf->isLenient();
 470   }
 471
 472   // The remaining attributea are only supported for DecimalFormat
 473   const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
 474   if (df != NULL) {
 475     UErrorCode ignoredStatus = U_ZERO_ERROR;
 476     return df->getAttribute( attr, ignoredStatus );
 477   }
 478
 479   return -1;
 480 }
 481
 482 U_CAPI void U_EXPORT2
 483 unum_setAttribute(    UNumberFormat*          fmt,
 484             UNumberFormatAttribute  attr,
 485             int32_t                 newValue)
 486 {
 487   NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
 488   if ( attr == UNUM_LENIENT_PARSE ) {
 489     // Supported for all subclasses
 490     // keep this here as the class may not be a DecimalFormat
 491     return nf->setLenient(newValue != 0);
 492   }
 493   // The remaining attributea are only supported for DecimalFormat
 494   DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
 495   if (df != NULL) {
 496     UErrorCode ignoredStatus = U_ZERO_ERROR;
 497     df->setAttribute(attr, newValue, ignoredStatus);
 498   }
 499 }
 500
 501 U_CAPI double U_EXPORT2
 502 unum_getDoubleAttribute(const UNumberFormat*          fmt,
 503           UNumberFormatAttribute  attr)
 504 {
 505     const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
 506     const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
 507     if (df != NULL &&  attr == UNUM_ROUNDING_INCREMENT) {
 508         return df->getRoundingIncrement();
 509     } else {
 510         return -1.0;
 511     }
 512 }
 513
 514 U_CAPI void U_EXPORT2
 515 unum_setDoubleAttribute(    UNumberFormat*          fmt,
 516             UNumberFormatAttribute  attr,
 517             double                 newValue)
 518 {
 519     NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
 520     DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
 521     if (df != NULL && attr == UNUM_ROUNDING_INCREMENT) {
 522         df->setRoundingIncrement(newValue);
 523     }
 524 }
 525
 526 U_CAPI int32_t U_EXPORT2
 527 unum_getTextAttribute(const UNumberFormat*  fmt,
 528             UNumberFormatTextAttribute      tag,
 529             UChar*                          result,
 530             int32_t                         resultLength,
 531             UErrorCode*                     status)
 532 {
 533     if(U_FAILURE(*status))
 534         return -1;
 535
 536     UnicodeString res;
 537     if(!(result==NULL && resultLength==0)) {
 538         // NULL destination for pure preflighting: empty dummy string
 539         // otherwise, alias the destination buffer
 540         res.setTo(result, 0, resultLength);
 541     }
 542
 543     const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
 544     const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
 545     if (df != NULL) {
 546         switch(tag) {
 547         case UNUM_POSITIVE_PREFIX:
 548             df->getPositivePrefix(res);
 549             break;
 550
 551         case UNUM_POSITIVE_SUFFIX:
 552             df->getPositiveSuffix(res);
 553             break;
 554
 555         case UNUM_NEGATIVE_PREFIX:
 556             df->getNegativePrefix(res);
 557             break;
 558
 559         case UNUM_NEGATIVE_SUFFIX:
 560             df->getNegativeSuffix(res);
 561             break;
 562
 563         case UNUM_PADDING_CHARACTER:
 564             res = df->getPadCharacterString();
 565             break;
 566
 567         case UNUM_CURRENCY_CODE:
 568             res = UnicodeString(df->getCurrency());
 569             break;
 570
 571         default:
 572             *status = U_UNSUPPORTED_ERROR;
 573             return -1;
 574         }
 575     } else {
 576         const RuleBasedNumberFormat* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(nf);
 577         U_ASSERT(rbnf != NULL);
 578         if (tag == UNUM_DEFAULT_RULESET) {
 579             res = rbnf->getDefaultRuleSetName();
 580         } else if (tag == UNUM_PUBLIC_RULESETS) {
 581             int32_t count = rbnf->getNumberOfRuleSetNames();
 582             for (int i = 0; i < count; ++i) {
 583                 res += rbnf->getRuleSetName(i);
 584                 res += (UChar)0x003b; // semicolon
 585             }
 586         } else {
 587             *status = U_UNSUPPORTED_ERROR;
 588             return -1;
 589         }
 590     }
 591
 592     return res.extract(result, resultLength, *status);
 593 }
 594
 595 U_CAPI void U_EXPORT2
 596 unum_setTextAttribute(    UNumberFormat*                    fmt,
 597             UNumberFormatTextAttribute      tag,
 598             const    UChar*                            newValue,
 599             int32_t                            newValueLength,
 600             UErrorCode                        *status)
 601 {
 602     if(U_FAILURE(*status))
 603         return;
 604
 605     UnicodeString val(newValue, newValueLength);
 606     NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
 607     DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
 608     if (df != NULL) {
 609       switch(tag) {
 610       case UNUM_POSITIVE_PREFIX:
 611         df->setPositivePrefix(val);
 612         break;
 613
 614       case UNUM_POSITIVE_SUFFIX:
 615         df->setPositiveSuffix(val);
 616         break;
 617
 618       case UNUM_NEGATIVE_PREFIX:
 619         df->setNegativePrefix(val);
 620         break;
 621
 622       case UNUM_NEGATIVE_SUFFIX:
 623         df->setNegativeSuffix(val);
 624         break;
 625
 626       case UNUM_PADDING_CHARACTER:
 627         df->setPadCharacter(val);
 628         break;
 629
 630       case UNUM_CURRENCY_CODE:
 631         df->setCurrency(val.getTerminatedBuffer(), *status);
 632         break;
 633
 634       default:
 635         *status = U_UNSUPPORTED_ERROR;
 636         break;
 637       }
 638     } else {
 639       RuleBasedNumberFormat* rbnf = dynamic_cast<RuleBasedNumberFormat*>(nf);
 640       U_ASSERT(rbnf != NULL);
 641       if (tag == UNUM_DEFAULT_RULESET) {
 642         rbnf->setDefaultRuleSet(val, *status);
 643       } else {
 644         *status = U_UNSUPPORTED_ERROR;
 645       }
 646     }
 647 }
 648
 649 U_CAPI int32_t U_EXPORT2
 650 unum_toPattern(    const    UNumberFormat*          fmt,
 651         UBool                  isPatternLocalized,
 652         UChar*                  result,
 653         int32_t                 resultLength,
 654         UErrorCode*             status)
 655 {
 656     if(U_FAILURE(*status))
 657         return -1;
 658
 659     UnicodeString pat;
 660     if(!(result==NULL && resultLength==0)) {
 661         // NULL destination for pure preflighting: empty dummy string
 662         // otherwise, alias the destination buffer
 663         pat.setTo(result, 0, resultLength);
 664     }
 665
 666     const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
 667     const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
 668     if (df != NULL) {
 669       if(isPatternLocalized)
 670         df->toLocalizedPattern(pat);
 671       else
 672         df->toPattern(pat);
 673     } else {
 674       const RuleBasedNumberFormat* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(nf);
 675       U_ASSERT(rbnf != NULL);
 676       pat = rbnf->getRules();
 677     }
 678     return pat.extract(result, resultLength, *status);
 679 }
 680
 681 U_CAPI int32_t U_EXPORT2
 682 unum_getSymbol(const UNumberFormat *fmt,
 683                UNumberFormatSymbol symbol,
 684                UChar *buffer,
 685                int32_t size,
 686                UErrorCode *status)
 687 {
 688     if(status==NULL || U_FAILURE(*status)) {
 689         return 0;
 690     }
 691     if(fmt==NULL || symbol< 0 || symbol>=UNUM_FORMAT_SYMBOL_COUNT) {
 692         *status=U_ILLEGAL_ARGUMENT_ERROR;
 693         return 0;
 694     }
 695     const NumberFormat *nf = reinterpret_cast<const NumberFormat *>(fmt);
 696     const DecimalFormat *dcf = dynamic_cast<const DecimalFormat *>(nf);
 697     if (dcf == NULL) {
 698       *status = U_UNSUPPORTED_ERROR;
 699       return 0;
 700     }
 701
 702     return dcf->
 703       getDecimalFormatSymbols()->
 704         getConstSymbol((DecimalFormatSymbols::ENumberFormatSymbol)symbol).
 705           extract(buffer, size, *status);
 706 }
 707
 708 U_CAPI void U_EXPORT2
 709 unum_setSymbol(UNumberFormat *fmt,
 710                UNumberFormatSymbol symbol,
 711                const UChar *value,
 712                int32_t length,
 713                UErrorCode *status)
 714 {
 715     if(status==NULL || U_FAILURE(*status)) {
 716         return;
 717     }
 718     if(fmt==NULL || symbol< 0 || symbol>=UNUM_FORMAT_SYMBOL_COUNT || value==NULL || length<-1) {
 719         *status=U_ILLEGAL_ARGUMENT_ERROR;
 720         return;
 721     }
 722     NumberFormat *nf = reinterpret_cast<NumberFormat *>(fmt);
 723     DecimalFormat *dcf = dynamic_cast<DecimalFormat *>(nf);
 724     if (dcf == NULL) {
 725       *status = U_UNSUPPORTED_ERROR;
 726       return;
 727     }
 728
 729     DecimalFormatSymbols symbols(*dcf->getDecimalFormatSymbols());
 730     symbols.setSymbol((DecimalFormatSymbols::ENumberFormatSymbol)symbol,
 731         UnicodeString(value, length));  /* UnicodeString can handle the case when length = -1. */
 732     dcf->setDecimalFormatSymbols(symbols);
 733 }
 734
 735 U_CAPI void U_EXPORT2
 736 unum_applyPattern(  UNumberFormat  *fmt,
 737                     UBool          localized,
 738                     const UChar    *pattern,
 739                     int32_t        patternLength,
 740                     UParseError    *parseError,
 741                     UErrorCode*    status)
 742 {
 743     UErrorCode tStatus = U_ZERO_ERROR;
 744     UParseError tParseError;
 745
 746     if(parseError == NULL){
 747         parseError = &tParseError;
 748     }
 749
 750     if(status==NULL){
 751         status = &tStatus;
 752     }
 753
 754     int32_t len = (patternLength == -1 ? u_strlen(pattern) : patternLength);
 755     const UnicodeString pat((UChar*)pattern, len, len);
 756
 757     // Verify if the object passed is a DecimalFormat object
 758     NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
 759     DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
 760     if (df != NULL) {
 761       if(localized) {
 762         df->applyLocalizedPattern(pat,*parseError, *status);
 763       } else {
 764         df->applyPattern(pat,*parseError, *status);
 765       }
 766     } else {
 767       *status = U_UNSUPPORTED_ERROR;
 768       return;
 769     }
 770 }
 771
 772 U_CAPI const char* U_EXPORT2
 773 unum_getLocaleByType(const UNumberFormat *fmt,
 774                      ULocDataLocaleType type,
 775                      UErrorCode* status)
 776 {
 777     if (fmt == NULL) {
 778         if (U_SUCCESS(*status)) {
 779             *status = U_ILLEGAL_ARGUMENT_ERROR;
 780         }
 781         return NULL;
 782     }
 783     return ((const Format*)fmt)->getLocaleID(type, *status);
 784 }
 785
 786 #endif /* #if !UCONFIG_NO_FORMATTING */