Home | History | Annotate | Download | only in numfmt 
      1 /********************************************************************
      2  * COPYRIGHT:
      3  * Copyright (c) 1999-2010, International Business Machines Corporation and
      4  * others. All Rights Reserved.
      5  ********************************************************************/
      6 
      7 #include "unicode/utypes.h"
      8 #include "unicode/unistr.h"
      9 #include "unicode/numfmt.h"
     10 #include "unicode/dcfmtsym.h"
     11 #include "unicode/decimfmt.h"
     12 #include "unicode/locid.h"
     13 #include "unicode/uclean.h"
     14 #include "util.h"
     15 #include <stdio.h>
     16 #include <stdlib.h>
     17 #include <string.h>
     18 
     19 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
     20 
     21 extern "C" void capi();
     22 void cppapi();
     23 
     24 static void
     25 showCurrencyFormatting(UBool useICU26API);
     26 
     27 int main(int argc, char **argv) {
     28     printf("%s output is in UTF-8\n", argv[0]);
     29 
     30     printf("C++ API\n");
     31     cppapi();
     32 
     33     printf("C API\n");
     34     capi();
     35 
     36     showCurrencyFormatting(FALSE);
     37     showCurrencyFormatting(TRUE);
     38 
     39     u_cleanup();    // Release any additional storage held by ICU.
     40 
     41     printf("Exiting successfully\n");
     42     return 0;
     43 }
     44 
     45 /**
     46  * Sample code for the C++ API to NumberFormat.
     47  */
     48 void cppapi() {
     49     Locale us("en", "US");
     50     UErrorCode status = U_ZERO_ERROR;
     51 
     52     // Create a number formatter for the US locale
     53     NumberFormat *fmt = NumberFormat::createInstance(us, status);
     54     check(status, "NumberFormat::createInstance");
     55 
     56     // Parse a string.  The string uses the digits '0' through '9'
     57     // and the decimal separator '.', standard in the US locale
     58     UnicodeString str("9876543210.123");
     59     Formattable result;
     60     fmt->parse(str, result, status);
     61     check(status, "NumberFormat::parse");
     62 
     63     printf("NumberFormat::parse(\""); // Display the result
     64     uprintf(str);
     65     printf("\") => ");
     66     uprintf(formattableToString(result));
     67     printf("\n");
     68 
     69     // Take the number parsed above, and use the formatter to
     70     // format it.
     71     str.remove(); // format() will APPEND to this string
     72     fmt->format(result, str, status);
     73     check(status, "NumberFormat::format");
     74 
     75     printf("NumberFormat::format("); // Display the result
     76     uprintf(formattableToString(result));
     77     printf(") => \"");
     78     uprintf(str);
     79     printf("\"\n");
     80 
     81     delete fmt; // Release the storage used by the formatter
     82 
     83 }
     84 
     85 // currency formatting ----------------------------------------------------- ***
     86 
     87 /*
     88  * Set a currency on a NumberFormat with pre-ICU 2.6 APIs.
     89  * This is a "hack" that will not work properly for all cases because
     90  * only ICU 2.6 introduced a more complete framework and data for this.
     91  *
     92  * @param nf The NumberFormat on which to set the currency; takes effect on
     93  *           currency-formatting NumberFormat instances.
     94  *           This must actually be a DecimalFormat instance.
     95  *           The display style of the output is controlled by nf (its pattern,
     96  *           usually from the display locale ID used to create this instance)
     97  *           while the currency symbol and number of decimals are set for
     98  *           the currency.
     99  * @param currency The 3-letter ISO 4217 currency code, NUL-terminated.
    100  * @param errorCode ICU error code, must pass U_SUCCESS() on input.
    101  */
    102 static void
    103 setNumberFormatCurrency_2_4(NumberFormat &nf, const char *currency, UErrorCode &errorCode) {
    104     // argument checking
    105     if(U_FAILURE(errorCode)) {
    106         return;
    107     }
    108     if(currency==NULL || strlen(currency)!=3) {
    109         errorCode=U_ILLEGAL_ARGUMENT_ERROR;
    110         return;
    111     }
    112 
    113     // check that the formatter is a DecimalFormat instance
    114     // necessary because we will cast to the DecimalFormat subclass to set
    115     // the currency symbol
    116     DecimalFormat *dnf=dynamic_cast<DecimalFormat *>(&nf);
    117     if(dnf==NULL) {
    118         errorCode=U_ILLEGAL_ARGUMENT_ERROR;
    119         return;
    120     }
    121 
    122     // map the currency code to a locale ID
    123     // only the currencies in this array are supported
    124     // it would be possible to map to a locale ID, instantiate a currency
    125     // formatter for that and copy its values, but that would be slower,
    126     // and we have to hardcode something here anyway
    127     static const struct {
    128         // ISO currency ID
    129         const char *currency;
    130 
    131         // fractionDigits==minimumFractionDigits==maximumFractionDigits
    132         // for these currencies
    133         int32_t fractionDigits;
    134 
    135         /*
    136          * Set the rounding increment to 0 if it is implied with the number of
    137          * fraction digits. Setting an explicit rounding increment makes
    138          * number formatting slower.
    139          * In other words, set it to something other than 0 only for unusual
    140          * cases like "nickel rounding" (0.05) when the increment differs from
    141          * 10^(-maximumFractionDigits).
    142          */
    143         double roundingIncrement;
    144 
    145         // Unicode string with the desired currency display symbol or name
    146         UChar symbol[16];
    147     } currencyMap[]={
    148         { "USD", 2, 0.0, { 0x24, 0 } },
    149         { "GBP", 2, 0.0, { 0xa3, 0 } },
    150         { "EUR", 2, 0.0, { 0x20ac, 0 } },
    151         { "JPY", 0, 0.0, { 0xa5, 0 } }
    152     };
    153 
    154     int32_t i;
    155 
    156     for(i=0; i<LENGTHOF(currencyMap); ++i) {
    157         if(strcmp(currency, currencyMap[i].currency)==0) {
    158             break;
    159         }
    160     }
    161     if(i==LENGTHOF(currencyMap)) {
    162         // a more specific error code would be useful in a real application
    163         errorCode=U_UNSUPPORTED_ERROR;
    164         return;
    165     }
    166 
    167     // set the currency-related data into the caller's formatter
    168 
    169     nf.setMinimumFractionDigits(currencyMap[i].fractionDigits);
    170     nf.setMaximumFractionDigits(currencyMap[i].fractionDigits);
    171 
    172     dnf->setRoundingIncrement(currencyMap[i].roundingIncrement);
    173 
    174     DecimalFormatSymbols symbols(*dnf->getDecimalFormatSymbols());
    175     symbols.setSymbol(DecimalFormatSymbols::kCurrencySymbol, currencyMap[i].symbol);
    176     dnf->setDecimalFormatSymbols(symbols); // do not adopt symbols: Jitterbug 2889
    177 }
    178 
    179 /*
    180  * Set a currency on a NumberFormat with ICU 2.6 APIs.
    181  *
    182  * @param nf The NumberFormat on which to set the currency; takes effect on
    183  *           currency-formatting NumberFormat instances.
    184  *           The display style of the output is controlled by nf (its pattern,
    185  *           usually from the display locale ID used to create this instance)
    186  *           while the currency symbol and number of decimals are set for
    187  *           the currency.
    188  * @param currency The 3-letter ISO 4217 currency code, NUL-terminated.
    189  * @param errorCode ICU error code, must pass U_SUCCESS() on input.
    190  */
    191 static void
    192 setNumberFormatCurrency_2_6(NumberFormat &nf, const char *currency, UErrorCode &errorCode) {
    193     if(U_FAILURE(errorCode)) {
    194         return;
    195     }
    196     if(currency==NULL || strlen(currency)!=3) {
    197         errorCode=U_ILLEGAL_ARGUMENT_ERROR;
    198         return;
    199     }
    200 
    201     // invariant-character conversion to UChars (see utypes.h and putil.h)
    202     UChar uCurrency[4];
    203     u_charsToUChars(currency, uCurrency, 4);
    204 
    205     // set the currency
    206     // in ICU 3.0 this API (which was @draft ICU 2.6) gained a UErrorCode& argument
    207 #if (U_ICU_VERSION_MAJOR_NUM < 3)
    208     nf.setCurrency(uCurrency);
    209 #else
    210     nf.setCurrency(uCurrency, errorCode);
    211 #endif
    212 }
    213 
    214 static const char *const
    215 sampleLocaleIDs[]={
    216     // use locale IDs complete with country code to be sure to
    217     // pick up number/currency format patterns
    218     "en_US", "en_GB", "de_DE", "ja_JP", "fr_FR", "hi_IN"
    219 };
    220 
    221 static const char *const
    222 sampleCurrencies[]={
    223     "USD", "GBP", "EUR", "JPY"
    224 };
    225 
    226 static void
    227 showCurrencyFormatting(UBool useICU26API) {
    228     NumberFormat *nf;
    229     int32_t i, j;
    230 
    231     UnicodeString output;
    232 
    233     UErrorCode errorCode;
    234 
    235     // TODO: Using printf() here assumes that the runtime encoding is ASCII-friendly
    236     // and can therefore be mixed with UTF-8
    237 
    238     for(i=0; i<LENGTHOF(sampleLocaleIDs); ++i) {
    239         printf("show currency formatting (method for %s) in the locale \"%s\"\n",
    240                 useICU26API ? "ICU 2.6" : "before ICU 2.6",
    241                 sampleLocaleIDs[i]);
    242 
    243         // get a currency formatter for this locale ID
    244         errorCode=U_ZERO_ERROR;
    245         nf=NumberFormat::createCurrencyInstance(sampleLocaleIDs[i], errorCode);
    246         if(U_FAILURE(errorCode)) {
    247             printf("NumberFormat::createCurrencyInstance(%s) failed - %s\n",
    248                     sampleLocaleIDs[i], u_errorName(errorCode));
    249             continue;
    250         }
    251 
    252         for(j=0; j<LENGTHOF(sampleCurrencies); ++j) {
    253             printf("  - format currency \"%s\": ", sampleCurrencies[j]);
    254 
    255             // set the actual currency to be formatted
    256             if(useICU26API) {
    257                 setNumberFormatCurrency_2_6(*nf, sampleCurrencies[j], errorCode);
    258             } else {
    259                 setNumberFormatCurrency_2_4(*nf, sampleCurrencies[j], errorCode);
    260             }
    261             if(U_FAILURE(errorCode)) {
    262                 printf("setNumberFormatCurrency(%s) failed - %s\n",
    263                         sampleCurrencies[j], u_errorName(errorCode));
    264                 continue;
    265             }
    266 
    267             // output=formatted currency value
    268             output.remove();
    269             nf->format(12345678.93, output);
    270             output+=(UChar)0x0a; // '\n'
    271             uprintf(output);
    272         }
    273     }
    274 }
    275