1999-08-16 21:50:52 +00:00
|
|
|
/*
|
1999-11-22 20:25:35 +00:00
|
|
|
*******************************************************************************
|
2014-01-14 07:31:30 +00:00
|
|
|
* Copyright (C) 1997-2014, International Business Machines Corporation and
|
2013-09-10 00:34:12 +00:00
|
|
|
* others. All Rights Reserved.
|
1999-11-22 20:25:35 +00:00
|
|
|
*******************************************************************************
|
1999-08-16 21:50:52 +00:00
|
|
|
*
|
|
|
|
* File NUMFMT.CPP
|
|
|
|
*
|
|
|
|
* Modification History:
|
|
|
|
*
|
|
|
|
* Date Name Description
|
|
|
|
* 02/19/97 aliu Converted from java.
|
|
|
|
* 03/18/97 clhuang Implemented with C++ APIs.
|
|
|
|
* 04/17/97 aliu Enlarged MAX_INTEGER_DIGITS to fully accomodate the
|
|
|
|
* largest double, by default.
|
|
|
|
* Changed DigitCount to int per code review.
|
|
|
|
* 07/20/98 stephen Changed operator== to check for grouping
|
|
|
|
* Changed setMaxIntegerDigits per Java implementation.
|
|
|
|
* Changed setMinIntegerDigits per Java implementation.
|
|
|
|
* Changed setMinFractionDigits per Java implementation.
|
|
|
|
* Changed setMaxFractionDigits per Java implementation.
|
|
|
|
********************************************************************************
|
|
|
|
*/
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2002-09-20 01:54:48 +00:00
|
|
|
#include "unicode/utypes.h"
|
|
|
|
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
|
1999-12-28 23:57:50 +00:00
|
|
|
#include "unicode/numfmt.h"
|
|
|
|
#include "unicode/locid.h"
|
|
|
|
#include "unicode/dcfmtsym.h"
|
|
|
|
#include "unicode/decimfmt.h"
|
2003-04-24 22:58:04 +00:00
|
|
|
#include "unicode/ustring.h"
|
2004-04-15 06:20:42 +00:00
|
|
|
#include "unicode/ucurr.h"
|
2004-04-27 21:47:09 +00:00
|
|
|
#include "unicode/curramt.h"
|
2009-01-22 04:46:35 +00:00
|
|
|
#include "unicode/numsys.h"
|
|
|
|
#include "unicode/rbnf.h"
|
2012-02-24 20:27:21 +00:00
|
|
|
#include "unicode/localpointer.h"
|
2014-01-14 07:31:30 +00:00
|
|
|
#include "unicode/udisplaycontext.h"
|
2011-04-29 00:00:47 +00:00
|
|
|
#include "charstr.h"
|
2006-01-12 19:53:58 +00:00
|
|
|
#include "winnmfmt.h"
|
2005-10-11 23:59:46 +00:00
|
|
|
#include "uresimp.h"
|
2003-02-27 20:14:51 +00:00
|
|
|
#include "uhash.h"
|
2004-06-03 17:44:02 +00:00
|
|
|
#include "cmemory.h"
|
2004-12-21 06:55:20 +00:00
|
|
|
#include "servloc.h"
|
2003-05-13 23:12:37 +00:00
|
|
|
#include "ucln_in.h"
|
2003-11-19 23:31:45 +00:00
|
|
|
#include "cstring.h"
|
2004-10-18 02:43:33 +00:00
|
|
|
#include "putilimp.h"
|
2013-05-31 23:50:15 +00:00
|
|
|
#include "uassert.h"
|
2009-07-28 20:22:32 +00:00
|
|
|
#include "umutex.h"
|
2011-04-29 00:00:47 +00:00
|
|
|
#include "mutex.h"
|
2010-02-26 02:29:00 +00:00
|
|
|
#include "digitlst.h"
|
1999-08-16 21:50:52 +00:00
|
|
|
#include <float.h>
|
|
|
|
|
2004-02-13 01:51:42 +00:00
|
|
|
//#define FMT_DEBUG
|
|
|
|
|
|
|
|
#ifdef FMT_DEBUG
|
|
|
|
#include <stdio.h>
|
2012-05-30 00:41:57 +00:00
|
|
|
static inline void debugout(UnicodeString s) {
|
2004-02-13 01:51:42 +00:00
|
|
|
char buf[2000];
|
|
|
|
s.extract((int32_t) 0, s.length(), buf);
|
|
|
|
printf("%s", buf);
|
|
|
|
}
|
|
|
|
#define debug(x) printf("%s", x);
|
|
|
|
#else
|
|
|
|
#define debugout(x)
|
|
|
|
#define debug(x)
|
|
|
|
#endif
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// If no number pattern can be located for a locale, this is the last
|
|
|
|
// resort.
|
2001-06-25 22:00:52 +00:00
|
|
|
static const UChar gLastResortDecimalPat[] = {
|
|
|
|
0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0x3B, 0x2D, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0 /* "#0.###;-#0.###" */
|
|
|
|
};
|
|
|
|
static const UChar gLastResortCurrencyPat[] = {
|
|
|
|
0x24, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x3B, 0x28, 0x24, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x29, 0 /* "$#0.00;($#0.00)" */
|
|
|
|
};
|
|
|
|
static const UChar gLastResortPercentPat[] = {
|
|
|
|
0x23, 0x30, 0x25, 0 /* "#0%" */
|
|
|
|
};
|
|
|
|
static const UChar gLastResortScientificPat[] = {
|
|
|
|
0x23, 0x45, 0x30, 0 /* "#E0" */
|
|
|
|
};
|
2009-02-12 22:55:29 +00:00
|
|
|
static const UChar gLastResortIsoCurrencyPat[] = {
|
|
|
|
0xA4, 0xA4, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x3B, 0x28, 0xA4, 0xA4, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x29, 0 /* "\u00A4\u00A4#0.00;(\u00A4\u00A4#0.00)" */
|
|
|
|
};
|
|
|
|
static const UChar gLastResortPluralCurrencyPat[] = {
|
|
|
|
0x23, 0x30, 0x2E, 0x30, 0x30, 0xA0, 0xA4, 0xA4, 0xA4, 0 /* "#0.00\u00A0\u00A4\u00A4\u00A4*/
|
|
|
|
};
|
|
|
|
|
|
|
|
static const UChar gSingleCurrencySign[] = {0xA4, 0};
|
|
|
|
static const UChar gDoubleCurrencySign[] = {0xA4, 0xA4, 0};
|
2001-10-08 23:26:58 +00:00
|
|
|
|
2009-02-23 22:41:41 +00:00
|
|
|
static const UChar gSlash = 0x2f;
|
|
|
|
|
2002-02-28 01:42:40 +00:00
|
|
|
// If the maximum base 10 exponent were 4, then the largest number would
|
2001-10-08 23:26:58 +00:00
|
|
|
// be 99,999 which has 5 digits.
|
2007-08-17 05:27:19 +00:00
|
|
|
// On IEEE754 systems gMaxIntegerDigits is 308 + possible denormalized 15 digits + rounding digit
|
2013-09-17 21:56:23 +00:00
|
|
|
// With big decimal, the max exponent is 999,999,999 and the max number of digits is the same, 999,999,999
|
2013-09-17 23:43:28 +00:00
|
|
|
const int32_t icu::NumberFormat::gDefaultMaxIntegerDigits = 2000000000;
|
|
|
|
const int32_t icu::NumberFormat::gDefaultMinIntegerDigits = 127;
|
2001-10-08 23:26:58 +00:00
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
static const UChar * const gLastResortNumberPatterns[UNUM_FORMAT_STYLE_COUNT] = {
|
|
|
|
NULL, // UNUM_PATTERN_DECIMAL
|
|
|
|
gLastResortDecimalPat, // UNUM_DECIMAL
|
|
|
|
gLastResortCurrencyPat, // UNUM_CURRENCY
|
|
|
|
gLastResortPercentPat, // UNUM_PERCENT
|
|
|
|
gLastResortScientificPat, // UNUM_SCIENTIFIC
|
|
|
|
NULL, // UNUM_SPELLOUT
|
|
|
|
NULL, // UNUM_ORDINAL
|
|
|
|
NULL, // UNUM_DURATION
|
|
|
|
NULL, // UNUM_NUMBERING_SYSTEM
|
|
|
|
NULL, // UNUM_PATTERN_RULEBASED
|
|
|
|
gLastResortIsoCurrencyPat, // UNUM_CURRENCY_ISO
|
|
|
|
gLastResortPluralCurrencyPat // UNUM_CURRENCY_PLURAL
|
1999-08-16 21:50:52 +00:00
|
|
|
};
|
|
|
|
|
2010-06-04 18:29:02 +00:00
|
|
|
// Keys used for accessing resource bundles
|
|
|
|
|
|
|
|
static const char *gNumberElements = "NumberElements";
|
|
|
|
static const char *gLatn = "latn";
|
|
|
|
static const char *gPatterns = "patterns";
|
2011-04-29 00:00:47 +00:00
|
|
|
static const char *gFormatKeys[UNUM_FORMAT_STYLE_COUNT] = {
|
|
|
|
NULL, // UNUM_PATTERN_DECIMAL
|
|
|
|
"decimalFormat", // UNUM_DECIMAL
|
|
|
|
"currencyFormat", // UNUM_CURRENCY
|
|
|
|
"percentFormat", // UNUM_PERCENT
|
|
|
|
"scientificFormat", // UNUM_SCIENTIFIC
|
|
|
|
NULL, // UNUM_SPELLOUT
|
|
|
|
NULL, // UNUM_ORDINAL
|
|
|
|
NULL, // UNUM_DURATION
|
|
|
|
NULL, // UNUM_NUMBERING_SYSTEM
|
|
|
|
NULL, // UNUM_PATTERN_RULEBASED
|
|
|
|
// For UNUM_CURRENCY_ISO and UNUM_CURRENCY_PLURAL,
|
|
|
|
// the pattern is the same as the pattern of UNUM_CURRENCY
|
|
|
|
// except for replacing the single currency sign with
|
|
|
|
// double currency sign or triple currency sign.
|
|
|
|
"currencyFormat", // UNUM_CURRENCY_ISO
|
|
|
|
"currencyFormat" // UNUM_CURRENCY_PLURAL
|
|
|
|
};
|
2010-06-04 18:29:02 +00:00
|
|
|
|
2010-01-28 19:39:24 +00:00
|
|
|
// Static hashtable cache of NumberingSystem objects used by NumberFormat
|
|
|
|
static UHashtable * NumberingSystem_cache = NULL;
|
2012-10-05 21:22:02 +00:00
|
|
|
static UMutex nscacheMutex = U_MUTEX_INITIALIZER;
|
2013-09-10 00:13:41 +00:00
|
|
|
static icu::UInitOnce gNSCacheInitOnce = U_INITONCE_INITIALIZER;
|
2009-07-29 22:13:15 +00:00
|
|
|
|
2009-09-23 15:41:25 +00:00
|
|
|
#if !UCONFIG_NO_SERVICE
|
2011-07-06 04:03:35 +00:00
|
|
|
static icu::ICULocaleService* gService = NULL;
|
2013-09-10 00:13:41 +00:00
|
|
|
static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER;
|
2009-09-23 15:41:25 +00:00
|
|
|
#endif
|
|
|
|
|
2010-01-28 19:39:24 +00:00
|
|
|
/**
|
|
|
|
* Release all static memory held by Number Format.
|
|
|
|
*/
|
|
|
|
U_CDECL_BEGIN
|
2009-07-24 15:19:11 +00:00
|
|
|
static void U_CALLCONV
|
|
|
|
deleteNumberingSystem(void *obj) {
|
2011-07-06 04:03:35 +00:00
|
|
|
delete (icu::NumberingSystem *)obj;
|
2009-07-24 15:19:11 +00:00
|
|
|
}
|
|
|
|
|
2009-09-23 15:41:25 +00:00
|
|
|
static UBool U_CALLCONV numfmt_cleanup(void) {
|
|
|
|
#if !UCONFIG_NO_SERVICE
|
2013-05-31 23:50:15 +00:00
|
|
|
gServiceInitOnce.reset();
|
2009-09-23 15:41:25 +00:00
|
|
|
if (gService) {
|
|
|
|
delete gService;
|
|
|
|
gService = NULL;
|
|
|
|
}
|
|
|
|
#endif
|
2013-05-31 23:50:15 +00:00
|
|
|
gNSCacheInitOnce.reset();
|
2010-01-28 19:39:24 +00:00
|
|
|
if (NumberingSystem_cache) {
|
|
|
|
// delete NumberingSystem_cache;
|
|
|
|
uhash_close(NumberingSystem_cache);
|
|
|
|
NumberingSystem_cache = NULL;
|
2009-09-23 15:41:25 +00:00
|
|
|
}
|
|
|
|
|
2010-01-28 19:39:24 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
2009-07-24 15:19:11 +00:00
|
|
|
U_CDECL_END
|
|
|
|
|
2004-12-22 23:32:48 +00:00
|
|
|
// *****************************************************************************
|
|
|
|
// class NumberFormat
|
|
|
|
// *****************************************************************************
|
|
|
|
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
|
|
|
|
UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(NumberFormat)
|
|
|
|
|
2004-10-08 06:23:24 +00:00
|
|
|
#if !UCONFIG_NO_SERVICE
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
2004-04-07 21:58:43 +00:00
|
|
|
// SimpleNumberFormatFactory implementation
|
2004-04-08 19:11:25 +00:00
|
|
|
NumberFormatFactory::~NumberFormatFactory() {}
|
2004-08-31 21:14:59 +00:00
|
|
|
SimpleNumberFormatFactory::SimpleNumberFormatFactory(const Locale& locale, UBool visible)
|
|
|
|
: _visible(visible)
|
|
|
|
{
|
2005-03-09 23:50:26 +00:00
|
|
|
LocaleUtility::initNameFromLocale(locale, _id);
|
2004-08-31 21:14:59 +00:00
|
|
|
}
|
|
|
|
|
2004-04-07 05:20:22 +00:00
|
|
|
SimpleNumberFormatFactory::~SimpleNumberFormatFactory() {}
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2004-04-07 21:58:43 +00:00
|
|
|
UBool SimpleNumberFormatFactory::visible(void) const {
|
|
|
|
return _visible;
|
|
|
|
}
|
|
|
|
|
|
|
|
const UnicodeString *
|
2010-01-28 19:39:24 +00:00
|
|
|
SimpleNumberFormatFactory::getSupportedIDs(int32_t &count, UErrorCode& status) const
|
2004-04-07 21:58:43 +00:00
|
|
|
{
|
|
|
|
if (U_SUCCESS(status)) {
|
|
|
|
count = 1;
|
|
|
|
return &_id;
|
|
|
|
}
|
|
|
|
count = 0;
|
|
|
|
return NULL;
|
|
|
|
}
|
2004-10-08 06:23:24 +00:00
|
|
|
#endif /* #if !UCONFIG_NO_SERVICE */
|
2004-04-07 21:58:43 +00:00
|
|
|
|
|
|
|
// -------------------------------------
|
|
|
|
// default constructor
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::NumberFormat()
|
|
|
|
: fGroupingUsed(TRUE),
|
2013-09-17 21:56:23 +00:00
|
|
|
fMaxIntegerDigits(gDefaultMaxIntegerDigits),
|
1999-08-16 21:50:52 +00:00
|
|
|
fMinIntegerDigits(1),
|
|
|
|
fMaxFractionDigits(3), // invariant, >= minFractionDigits
|
|
|
|
fMinFractionDigits(0),
|
2011-05-04 12:23:42 +00:00
|
|
|
fParseIntegerOnly(FALSE),
|
2014-01-15 08:34:01 +00:00
|
|
|
fLenient(FALSE),
|
|
|
|
fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2004-02-13 01:51:42 +00:00
|
|
|
fCurrency[0] = 0;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------
|
|
|
|
|
|
|
|
NumberFormat::~NumberFormat()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------
|
|
|
|
// copy constructor
|
|
|
|
|
|
|
|
NumberFormat::NumberFormat(const NumberFormat &source)
|
2001-05-24 21:11:44 +00:00
|
|
|
: Format(source)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
|
|
|
*this = source;
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------
|
|
|
|
// assignment operator
|
|
|
|
|
|
|
|
NumberFormat&
|
|
|
|
NumberFormat::operator=(const NumberFormat& rhs)
|
|
|
|
{
|
|
|
|
if (this != &rhs)
|
|
|
|
{
|
2010-02-26 02:29:00 +00:00
|
|
|
Format::operator=(rhs);
|
1999-08-16 21:50:52 +00:00
|
|
|
fGroupingUsed = rhs.fGroupingUsed;
|
|
|
|
fMaxIntegerDigits = rhs.fMaxIntegerDigits;
|
|
|
|
fMinIntegerDigits = rhs.fMinIntegerDigits;
|
|
|
|
fMaxFractionDigits = rhs.fMaxFractionDigits;
|
|
|
|
fMinFractionDigits = rhs.fMinFractionDigits;
|
|
|
|
fParseIntegerOnly = rhs.fParseIntegerOnly;
|
2004-02-13 01:51:42 +00:00
|
|
|
u_strncpy(fCurrency, rhs.fCurrency, 4);
|
2011-05-09 02:35:48 +00:00
|
|
|
fLenient = rhs.fLenient;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2000-05-18 22:08:39 +00:00
|
|
|
UBool
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::operator==(const Format& that) const
|
|
|
|
{
|
2004-02-13 01:51:42 +00:00
|
|
|
// Format::operator== guarantees this cast is safe
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat* other = (NumberFormat*)&that;
|
|
|
|
|
2004-02-13 01:51:42 +00:00
|
|
|
#ifdef FMT_DEBUG
|
|
|
|
// This code makes it easy to determine why two format objects that should
|
|
|
|
// be equal aren't.
|
|
|
|
UBool first = TRUE;
|
|
|
|
if (!Format::operator==(that)) {
|
|
|
|
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
|
|
|
|
debug("Format::!=");
|
|
|
|
}
|
|
|
|
if (!(fMaxIntegerDigits == other->fMaxIntegerDigits &&
|
|
|
|
fMinIntegerDigits == other->fMinIntegerDigits)) {
|
|
|
|
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
|
|
|
|
debug("Integer digits !=");
|
|
|
|
}
|
|
|
|
if (!(fMaxFractionDigits == other->fMaxFractionDigits &&
|
|
|
|
fMinFractionDigits == other->fMinFractionDigits)) {
|
|
|
|
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
|
|
|
|
debug("Fraction digits !=");
|
|
|
|
}
|
|
|
|
if (!(fGroupingUsed == other->fGroupingUsed)) {
|
|
|
|
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
|
|
|
|
debug("fGroupingUsed != ");
|
|
|
|
}
|
|
|
|
if (!(fParseIntegerOnly == other->fParseIntegerOnly)) {
|
|
|
|
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
|
|
|
|
debug("fParseIntegerOnly != ");
|
|
|
|
}
|
|
|
|
if (!(u_strcmp(fCurrency, other->fCurrency) == 0)) {
|
|
|
|
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
|
|
|
|
debug("fCurrency !=");
|
|
|
|
}
|
2011-05-09 02:35:48 +00:00
|
|
|
if (!(fLenient == other->fLenient)) {
|
|
|
|
if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
|
|
|
|
debug("fLenient != ");
|
|
|
|
}
|
2010-01-28 19:39:24 +00:00
|
|
|
if (!first) { printf(" ]"); }
|
2004-02-13 01:51:42 +00:00
|
|
|
#endif
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
return ((this == &that) ||
|
|
|
|
((Format::operator==(that) &&
|
|
|
|
fMaxIntegerDigits == other->fMaxIntegerDigits &&
|
|
|
|
fMinIntegerDigits == other->fMinIntegerDigits &&
|
|
|
|
fMaxFractionDigits == other->fMaxFractionDigits &&
|
|
|
|
fMinFractionDigits == other->fMinFractionDigits &&
|
|
|
|
fGroupingUsed == other->fGroupingUsed &&
|
2004-02-13 01:51:42 +00:00
|
|
|
fParseIntegerOnly == other->fParseIntegerOnly &&
|
2011-05-09 02:35:48 +00:00
|
|
|
u_strcmp(fCurrency, other->fCurrency) == 0 &&
|
|
|
|
fLenient == other->fLenient)));
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2009-12-17 22:15:20 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Default implementation sets unsupported error; subclasses should
|
|
|
|
// override.
|
|
|
|
|
|
|
|
UnicodeString&
|
|
|
|
NumberFormat::format(double /* unused number */,
|
|
|
|
UnicodeString& toAppendTo,
|
2010-01-28 19:39:24 +00:00
|
|
|
FieldPositionIterator* /* unused posIter */,
|
2009-12-17 22:15:20 +00:00
|
|
|
UErrorCode& status) const
|
|
|
|
{
|
|
|
|
if (!U_FAILURE(status)) {
|
|
|
|
status = U_UNSUPPORTED_ERROR;
|
|
|
|
}
|
|
|
|
return toAppendTo;
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------
|
|
|
|
// Default implementation sets unsupported error; subclasses should
|
|
|
|
// override.
|
|
|
|
|
|
|
|
UnicodeString&
|
|
|
|
NumberFormat::format(int32_t /* unused number */,
|
|
|
|
UnicodeString& toAppendTo,
|
2010-01-28 19:39:24 +00:00
|
|
|
FieldPositionIterator* /* unused posIter */,
|
2009-12-17 22:15:20 +00:00
|
|
|
UErrorCode& status) const
|
|
|
|
{
|
|
|
|
if (!U_FAILURE(status)) {
|
|
|
|
status = U_UNSUPPORTED_ERROR;
|
|
|
|
}
|
|
|
|
return toAppendTo;
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------
|
|
|
|
// Default implementation sets unsupported error; subclasses should
|
|
|
|
// override.
|
|
|
|
|
|
|
|
UnicodeString&
|
|
|
|
NumberFormat::format(int64_t /* unused number */,
|
|
|
|
UnicodeString& toAppendTo,
|
2010-01-28 19:39:24 +00:00
|
|
|
FieldPositionIterator* /* unused posIter */,
|
2009-12-17 22:15:20 +00:00
|
|
|
UErrorCode& status) const
|
|
|
|
{
|
|
|
|
if (!U_FAILURE(status)) {
|
|
|
|
status = U_UNSUPPORTED_ERROR;
|
|
|
|
}
|
|
|
|
return toAppendTo;
|
|
|
|
}
|
|
|
|
|
2012-10-12 19:52:43 +00:00
|
|
|
// ------------------------------------------
|
|
|
|
// These functions add the status code, just fall back to the non-status versions
|
|
|
|
UnicodeString&
|
|
|
|
NumberFormat::format(double number,
|
|
|
|
UnicodeString& appendTo,
|
|
|
|
FieldPosition& pos,
|
|
|
|
UErrorCode &status) const {
|
|
|
|
if(U_SUCCESS(status)) {
|
|
|
|
return format(number,appendTo,pos);
|
|
|
|
} else {
|
|
|
|
return appendTo;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
UnicodeString&
|
|
|
|
NumberFormat::format(int32_t number,
|
|
|
|
UnicodeString& appendTo,
|
|
|
|
FieldPosition& pos,
|
|
|
|
UErrorCode &status) const {
|
|
|
|
if(U_SUCCESS(status)) {
|
|
|
|
return format(number,appendTo,pos);
|
|
|
|
} else {
|
|
|
|
return appendTo;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
UnicodeString&
|
|
|
|
NumberFormat::format(int64_t number,
|
|
|
|
UnicodeString& appendTo,
|
|
|
|
FieldPosition& pos,
|
|
|
|
UErrorCode &status) const {
|
|
|
|
if(U_SUCCESS(status)) {
|
|
|
|
return format(number,appendTo,pos);
|
|
|
|
} else {
|
|
|
|
return appendTo;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2010-01-15 22:28:39 +00:00
|
|
|
// -------------------------------------
|
2010-02-26 02:29:00 +00:00
|
|
|
// Decimal Number format() default implementation
|
|
|
|
// Subclasses do not normally override this function, but rather the DigitList
|
|
|
|
// formatting functions..
|
|
|
|
// The expected call chain from here is
|
|
|
|
// this function ->
|
|
|
|
// NumberFormat::format(Formattable ->
|
|
|
|
// DecimalFormat::format(DigitList
|
|
|
|
//
|
|
|
|
// Or, for subclasses of Formattable that do not know about DigitList,
|
|
|
|
// this Function ->
|
|
|
|
// NumberFormat::format(Formattable ->
|
|
|
|
// NumberFormat::format(DigitList ->
|
|
|
|
// XXXFormat::format(double
|
2010-01-15 22:28:39 +00:00
|
|
|
|
|
|
|
UnicodeString&
|
2010-02-26 02:29:00 +00:00
|
|
|
NumberFormat::format(const StringPiece &decimalNum,
|
2010-01-15 22:28:39 +00:00
|
|
|
UnicodeString& toAppendTo,
|
2010-02-26 02:29:00 +00:00
|
|
|
FieldPositionIterator* fpi,
|
2010-01-15 22:28:39 +00:00
|
|
|
UErrorCode& status) const
|
|
|
|
{
|
2010-02-26 02:29:00 +00:00
|
|
|
Formattable f;
|
|
|
|
f.setDecimalNumber(decimalNum, status);
|
|
|
|
format(f, toAppendTo, fpi, status);
|
2010-01-15 22:28:39 +00:00
|
|
|
return toAppendTo;
|
|
|
|
}
|
|
|
|
|
2013-09-05 05:32:56 +00:00
|
|
|
/**
|
|
|
|
*
|
1999-08-16 21:50:52 +00:00
|
|
|
// Formats the number object and save the format
|
|
|
|
// result in the toAppendTo string buffer.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2010-01-28 19:39:24 +00:00
|
|
|
// utility to save/restore state, used in two overloads
|
2009-12-17 22:15:20 +00:00
|
|
|
// of format(const Formattable&...) below.
|
2013-09-05 05:32:56 +00:00
|
|
|
*
|
|
|
|
* Old purpose of ArgExtractor was to avoid const. Not thread safe!
|
|
|
|
*
|
|
|
|
* keeping it around as a shim.
|
|
|
|
*/
|
2009-12-17 22:15:20 +00:00
|
|
|
class ArgExtractor {
|
|
|
|
const Formattable* num;
|
|
|
|
UChar save[4];
|
2013-09-05 05:32:56 +00:00
|
|
|
UBool fWasCurrency;
|
2009-12-17 22:15:20 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
ArgExtractor(const NumberFormat& nf, const Formattable& obj, UErrorCode& status);
|
|
|
|
~ArgExtractor();
|
|
|
|
|
|
|
|
const Formattable* number(void) const;
|
2013-09-05 05:32:56 +00:00
|
|
|
const UChar *iso(void) const;
|
2013-09-18 20:08:25 +00:00
|
|
|
UBool wasCurrency(void) const;
|
2009-12-17 22:15:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
inline const Formattable*
|
|
|
|
ArgExtractor::number(void) const {
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
2013-09-18 20:08:25 +00:00
|
|
|
inline UBool
|
2013-09-05 05:32:56 +00:00
|
|
|
ArgExtractor::wasCurrency(void) const {
|
|
|
|
return fWasCurrency;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline const UChar *
|
|
|
|
ArgExtractor::iso(void) const {
|
|
|
|
return save;
|
|
|
|
}
|
2013-09-04 01:07:35 +00:00
|
|
|
|
2013-09-18 20:08:25 +00:00
|
|
|
ArgExtractor::ArgExtractor(const NumberFormat& /*nf*/, const Formattable& obj, UErrorCode& /*status*/)
|
2013-09-05 05:32:56 +00:00
|
|
|
: num(&obj), fWasCurrency(FALSE) {
|
2004-04-15 06:20:42 +00:00
|
|
|
|
2004-04-27 21:47:09 +00:00
|
|
|
const UObject* o = obj.getObject(); // most commonly o==NULL
|
2010-05-19 17:29:33 +00:00
|
|
|
const CurrencyAmount* amt;
|
|
|
|
if (o != NULL && (amt = dynamic_cast<const CurrencyAmount*>(o)) != NULL) {
|
2004-04-27 21:47:09 +00:00
|
|
|
// getISOCurrency() returns a pointer to internal storage, so we
|
2004-04-15 06:20:42 +00:00
|
|
|
// copy it to retain it across the call to setCurrency().
|
2013-09-05 05:32:56 +00:00
|
|
|
//const UChar* curr = amt->getISOCurrency();
|
|
|
|
u_strcpy(save, amt->getISOCurrency());
|
2009-12-17 22:15:20 +00:00
|
|
|
num = &amt->getNumber();
|
2013-09-05 05:32:56 +00:00
|
|
|
fWasCurrency=TRUE;
|
|
|
|
} else {
|
|
|
|
save[0]=0;
|
2003-10-31 22:47:25 +00:00
|
|
|
}
|
2009-12-17 22:15:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ArgExtractor::~ArgExtractor() {
|
|
|
|
}
|
|
|
|
|
2010-02-26 02:29:00 +00:00
|
|
|
UnicodeString& NumberFormat::format(const DigitList &number,
|
|
|
|
UnicodeString& appendTo,
|
|
|
|
FieldPositionIterator* posIter,
|
|
|
|
UErrorCode& status) const {
|
|
|
|
// DecimalFormat overrides this function, and handles DigitList based big decimals.
|
|
|
|
// Other subclasses (ChoiceFormat, RuleBasedNumberFormat) do not (yet) handle DigitLists,
|
|
|
|
// so this default implementation falls back to formatting decimal numbers as doubles.
|
|
|
|
if (U_FAILURE(status)) {
|
|
|
|
return appendTo;
|
|
|
|
}
|
|
|
|
double dnum = number.getDouble();
|
|
|
|
format(dnum, appendTo, posIter, status);
|
|
|
|
return appendTo;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
UnicodeString&
|
|
|
|
NumberFormat::format(const DigitList &number,
|
|
|
|
UnicodeString& appendTo,
|
|
|
|
FieldPosition& pos,
|
|
|
|
UErrorCode &status) const {
|
|
|
|
// DecimalFormat overrides this function, and handles DigitList based big decimals.
|
|
|
|
// Other subclasses (ChoiceFormat, RuleBasedNumberFormat) do not (yet) handle DigitLists,
|
|
|
|
// so this default implementation falls back to formatting decimal numbers as doubles.
|
|
|
|
if (U_FAILURE(status)) {
|
|
|
|
return appendTo;
|
|
|
|
}
|
|
|
|
double dnum = number.getDouble();
|
|
|
|
format(dnum, appendTo, pos, status);
|
|
|
|
return appendTo;
|
|
|
|
}
|
|
|
|
|
2009-12-17 22:15:20 +00:00
|
|
|
UnicodeString&
|
|
|
|
NumberFormat::format(const Formattable& obj,
|
|
|
|
UnicodeString& appendTo,
|
|
|
|
FieldPosition& pos,
|
|
|
|
UErrorCode& status) const
|
|
|
|
{
|
|
|
|
if (U_FAILURE(status)) return appendTo;
|
|
|
|
|
|
|
|
ArgExtractor arg(*this, obj, status);
|
|
|
|
const Formattable *n = arg.number();
|
2013-09-05 05:32:56 +00:00
|
|
|
const UChar *iso = arg.iso();
|
|
|
|
|
|
|
|
if(arg.wasCurrency() && u_strcmp(iso, getCurrency())) {
|
|
|
|
// trying to format a different currency.
|
|
|
|
// Right now, we clone.
|
|
|
|
LocalPointer<NumberFormat> cloneFmt((NumberFormat*)this->clone());
|
|
|
|
cloneFmt->setCurrency(iso, status);
|
|
|
|
// next line should NOT recurse, because n is numeric whereas obj was a wrapper around currency amount.
|
|
|
|
return cloneFmt->format(*n, appendTo, pos, status);
|
|
|
|
}
|
2004-04-15 06:20:42 +00:00
|
|
|
|
2010-02-26 02:29:00 +00:00
|
|
|
if (n->isNumeric() && n->getDigitList() != NULL) {
|
|
|
|
// Decimal Number. We will have a DigitList available if the value was
|
|
|
|
// set to a decimal number, or if the value originated with a parse.
|
|
|
|
//
|
|
|
|
// The default implementation for formatting a DigitList converts it
|
|
|
|
// to a double, and formats that, allowing formatting classes that don't
|
|
|
|
// know about DigitList to continue to operate as they had.
|
|
|
|
//
|
|
|
|
// DecimalFormat overrides the DigitList formatting functions.
|
|
|
|
format(*n->getDigitList(), appendTo, pos, status);
|
|
|
|
} else {
|
|
|
|
switch (n->getType()) {
|
|
|
|
case Formattable::kDouble:
|
|
|
|
format(n->getDouble(), appendTo, pos);
|
|
|
|
break;
|
|
|
|
case Formattable::kLong:
|
|
|
|
format(n->getLong(), appendTo, pos);
|
|
|
|
break;
|
|
|
|
case Formattable::kInt64:
|
|
|
|
format(n->getInt64(), appendTo, pos);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
|
|
break;
|
|
|
|
}
|
2004-04-15 06:20:42 +00:00
|
|
|
}
|
|
|
|
|
2009-12-17 22:15:20 +00:00
|
|
|
return appendTo;
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------x
|
|
|
|
// Formats the number object and save the format
|
|
|
|
// result in the toAppendTo string buffer.
|
|
|
|
|
|
|
|
UnicodeString&
|
|
|
|
NumberFormat::format(const Formattable& obj,
|
|
|
|
UnicodeString& appendTo,
|
2010-01-28 19:39:24 +00:00
|
|
|
FieldPositionIterator* posIter,
|
2009-12-17 22:15:20 +00:00
|
|
|
UErrorCode& status) const
|
|
|
|
{
|
|
|
|
if (U_FAILURE(status)) return appendTo;
|
|
|
|
|
|
|
|
ArgExtractor arg(*this, obj, status);
|
|
|
|
const Formattable *n = arg.number();
|
2013-09-05 05:32:56 +00:00
|
|
|
const UChar *iso = arg.iso();
|
|
|
|
|
|
|
|
if(arg.wasCurrency() && u_strcmp(iso, getCurrency())) {
|
|
|
|
// trying to format a different currency.
|
|
|
|
// Right now, we clone.
|
|
|
|
LocalPointer<NumberFormat> cloneFmt((NumberFormat*)this->clone());
|
|
|
|
cloneFmt->setCurrency(iso, status);
|
|
|
|
// next line should NOT recurse, because n is numeric whereas obj was a wrapper around currency amount.
|
|
|
|
return cloneFmt->format(*n, appendTo, posIter, status);
|
|
|
|
}
|
2009-12-17 22:15:20 +00:00
|
|
|
|
2010-02-26 02:29:00 +00:00
|
|
|
if (n->isNumeric() && n->getDigitList() != NULL) {
|
|
|
|
// Decimal Number
|
|
|
|
format(*n->getDigitList(), appendTo, posIter, status);
|
|
|
|
} else {
|
|
|
|
switch (n->getType()) {
|
|
|
|
case Formattable::kDouble:
|
|
|
|
format(n->getDouble(), appendTo, posIter, status);
|
|
|
|
break;
|
|
|
|
case Formattable::kLong:
|
|
|
|
format(n->getLong(), appendTo, posIter, status);
|
|
|
|
break;
|
|
|
|
case Formattable::kInt64:
|
|
|
|
format(n->getInt64(), appendTo, posIter, status);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
|
|
break;
|
|
|
|
}
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2009-12-17 22:15:20 +00:00
|
|
|
|
2004-04-15 06:20:42 +00:00
|
|
|
return appendTo;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2003-10-31 22:47:25 +00:00
|
|
|
// -------------------------------------
|
|
|
|
|
2010-01-28 19:39:24 +00:00
|
|
|
UnicodeString&
|
2003-10-31 22:47:25 +00:00
|
|
|
NumberFormat::format(int64_t number,
|
|
|
|
UnicodeString& appendTo,
|
|
|
|
FieldPosition& pos) const
|
|
|
|
{
|
2004-11-11 23:34:58 +00:00
|
|
|
// default so we don't introduce a new abstract method
|
|
|
|
return format((int32_t)number, appendTo, pos);
|
2003-10-31 22:47:25 +00:00
|
|
|
}
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Parses the string and save the result object as well
|
|
|
|
// as the final parsed position.
|
|
|
|
|
|
|
|
void
|
|
|
|
NumberFormat::parseObject(const UnicodeString& source,
|
|
|
|
Formattable& result,
|
|
|
|
ParsePosition& parse_pos) const
|
|
|
|
{
|
|
|
|
parse(source, result, parse_pos);
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Formats a double number and save the result in a string.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
UnicodeString&
|
2002-11-23 01:11:50 +00:00
|
|
|
NumberFormat::format(double number, UnicodeString& appendTo) const
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2000-11-02 20:22:02 +00:00
|
|
|
FieldPosition pos(0);
|
2002-11-23 01:11:50 +00:00
|
|
|
return format(number, appendTo, pos);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Formats a long number and save the result in a string.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
UnicodeString&
|
2002-11-23 01:11:50 +00:00
|
|
|
NumberFormat::format(int32_t number, UnicodeString& appendTo) const
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2000-11-02 20:22:02 +00:00
|
|
|
FieldPosition pos(0);
|
2002-11-23 01:11:50 +00:00
|
|
|
return format(number, appendTo, pos);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2003-10-31 22:47:25 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Formats a long number and save the result in a string.
|
|
|
|
|
|
|
|
UnicodeString&
|
|
|
|
NumberFormat::format(int64_t number, UnicodeString& appendTo) const
|
|
|
|
{
|
|
|
|
FieldPosition pos(0);
|
|
|
|
return format(number, appendTo, pos);
|
|
|
|
}
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Parses the text and save the result object. If the returned
|
|
|
|
// parse position is 0, that means the parsing failed, the status
|
2002-02-28 01:42:40 +00:00
|
|
|
// code needs to be set to failure. Ignores the returned parse
|
1999-08-16 21:50:52 +00:00
|
|
|
// position, otherwise.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
void
|
|
|
|
NumberFormat::parse(const UnicodeString& text,
|
|
|
|
Formattable& result,
|
|
|
|
UErrorCode& status) const
|
|
|
|
{
|
1999-10-18 22:48:32 +00:00
|
|
|
if (U_FAILURE(status)) return;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
ParsePosition parsePosition(0);
|
|
|
|
parse(text, result, parsePosition);
|
|
|
|
if (parsePosition.getIndex() == 0) {
|
1999-10-07 00:07:53 +00:00
|
|
|
status = U_INVALID_FORMAT_ERROR;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2012-02-19 06:45:47 +00:00
|
|
|
CurrencyAmount* NumberFormat::parseCurrency(const UnicodeString& text,
|
|
|
|
ParsePosition& pos) const {
|
2004-04-15 06:20:42 +00:00
|
|
|
// Default implementation only -- subclasses should override
|
2012-02-19 06:45:47 +00:00
|
|
|
Formattable parseResult;
|
2004-04-15 06:20:42 +00:00
|
|
|
int32_t start = pos.getIndex();
|
2012-02-19 06:45:47 +00:00
|
|
|
parse(text, parseResult, pos);
|
2012-02-24 20:27:21 +00:00
|
|
|
if (pos.getIndex() != start) {
|
2004-04-15 06:20:42 +00:00
|
|
|
UChar curr[4];
|
|
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
|
|
getEffectiveCurrency(curr, ec);
|
|
|
|
if (U_SUCCESS(ec)) {
|
2012-02-24 20:27:21 +00:00
|
|
|
LocalPointer<CurrencyAmount> currAmt(new CurrencyAmount(parseResult, curr, ec));
|
|
|
|
if (U_FAILURE(ec)) {
|
2004-04-27 21:47:09 +00:00
|
|
|
pos.setIndex(start); // indicate failure
|
2012-02-24 20:27:21 +00:00
|
|
|
} else {
|
2012-02-24 22:54:57 +00:00
|
|
|
return currAmt.orphan();
|
2004-04-27 21:47:09 +00:00
|
|
|
}
|
2004-04-15 06:20:42 +00:00
|
|
|
}
|
|
|
|
}
|
2012-02-24 22:54:57 +00:00
|
|
|
return NULL;
|
2004-04-15 06:20:42 +00:00
|
|
|
}
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Sets to only parse integers.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
void
|
2000-05-18 22:08:39 +00:00
|
|
|
NumberFormat::setParseIntegerOnly(UBool value)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
|
|
|
fParseIntegerOnly = value;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2011-05-04 12:23:42 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Sets whether lenient parse is enabled.
|
|
|
|
|
|
|
|
void
|
|
|
|
NumberFormat::setLenient(UBool enable)
|
|
|
|
{
|
|
|
|
fLenient = enable;
|
|
|
|
}
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Create a number style NumberFormat instance with the default locale.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
NumberFormat* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::createInstance(UErrorCode& status)
|
|
|
|
{
|
2011-04-29 00:00:47 +00:00
|
|
|
return createInstance(Locale::getDefault(), UNUM_DECIMAL, status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Create a number style NumberFormat instance with the inLocale locale.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
NumberFormat* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::createInstance(const Locale& inLocale, UErrorCode& status)
|
|
|
|
{
|
2011-04-29 00:00:47 +00:00
|
|
|
return createInstance(inLocale, UNUM_DECIMAL, status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Create a currency style NumberFormat instance with the default locale.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
NumberFormat* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::createCurrencyInstance(UErrorCode& status)
|
|
|
|
{
|
2004-06-03 17:44:02 +00:00
|
|
|
return createCurrencyInstance(Locale::getDefault(), status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Create a currency style NumberFormat instance with the inLocale locale.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
NumberFormat* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::createCurrencyInstance(const Locale& inLocale, UErrorCode& status)
|
2010-01-28 19:39:24 +00:00
|
|
|
{
|
2011-04-29 00:00:47 +00:00
|
|
|
return createInstance(inLocale, UNUM_CURRENCY, status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Create a percent style NumberFormat instance with the default locale.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
NumberFormat* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::createPercentInstance(UErrorCode& status)
|
|
|
|
{
|
2011-04-29 00:00:47 +00:00
|
|
|
return createInstance(Locale::getDefault(), UNUM_PERCENT, status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Create a percent style NumberFormat instance with the inLocale locale.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
NumberFormat* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::createPercentInstance(const Locale& inLocale, UErrorCode& status)
|
|
|
|
{
|
2011-04-29 00:00:47 +00:00
|
|
|
return createInstance(inLocale, UNUM_PERCENT, status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Create a scientific style NumberFormat instance with the default locale.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
NumberFormat* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::createScientificInstance(UErrorCode& status)
|
|
|
|
{
|
2011-04-29 00:00:47 +00:00
|
|
|
return createInstance(Locale::getDefault(), UNUM_SCIENTIFIC, status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Create a scientific style NumberFormat instance with the inLocale locale.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
NumberFormat* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::createScientificInstance(const Locale& inLocale, UErrorCode& status)
|
|
|
|
{
|
2011-04-29 00:00:47 +00:00
|
|
|
return createInstance(inLocale, UNUM_SCIENTIFIC, status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
const Locale* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::getAvailableLocales(int32_t& count)
|
|
|
|
{
|
|
|
|
return Locale::getAvailableLocales(count);
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2003-02-25 23:36:48 +00:00
|
|
|
// ------------------------------------------
|
|
|
|
//
|
|
|
|
// Registration
|
|
|
|
//
|
|
|
|
//-------------------------------------------
|
|
|
|
|
2004-07-18 01:37:13 +00:00
|
|
|
#if !UCONFIG_NO_SERVICE
|
2004-09-12 23:07:29 +00:00
|
|
|
|
2003-02-25 23:36:48 +00:00
|
|
|
// -------------------------------------
|
|
|
|
|
|
|
|
class ICUNumberFormatFactory : public ICUResourceBundleFactory {
|
2011-07-26 05:32:25 +00:00
|
|
|
public:
|
|
|
|
virtual ~ICUNumberFormatFactory();
|
2003-02-25 23:36:48 +00:00
|
|
|
protected:
|
2004-08-24 17:38:33 +00:00
|
|
|
virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /* service */, UErrorCode& status) const {
|
2011-04-29 00:00:47 +00:00
|
|
|
return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status);
|
2004-08-24 17:38:33 +00:00
|
|
|
}
|
2003-02-25 23:36:48 +00:00
|
|
|
};
|
|
|
|
|
2011-07-26 05:32:25 +00:00
|
|
|
ICUNumberFormatFactory::~ICUNumberFormatFactory() {}
|
|
|
|
|
2003-02-25 23:36:48 +00:00
|
|
|
// -------------------------------------
|
|
|
|
|
|
|
|
class NFFactory : public LocaleKeyFactory {
|
|
|
|
private:
|
2004-08-24 17:38:33 +00:00
|
|
|
NumberFormatFactory* _delegate;
|
|
|
|
Hashtable* _ids;
|
2003-02-25 23:36:48 +00:00
|
|
|
|
|
|
|
public:
|
2010-01-28 19:39:24 +00:00
|
|
|
NFFactory(NumberFormatFactory* delegate)
|
2004-08-24 17:38:33 +00:00
|
|
|
: LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE)
|
|
|
|
, _delegate(delegate)
|
|
|
|
, _ids(NULL)
|
|
|
|
{
|
|
|
|
}
|
2003-02-25 23:36:48 +00:00
|
|
|
|
2011-07-26 05:32:25 +00:00
|
|
|
virtual ~NFFactory();
|
2003-02-27 20:14:51 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const
|
|
|
|
{
|
|
|
|
if (handlesKey(key, status)) {
|
|
|
|
const LocaleKey& lkey = (const LocaleKey&)key;
|
|
|
|
Locale loc;
|
|
|
|
lkey.canonicalLocale(loc);
|
|
|
|
int32_t kind = lkey.kind();
|
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
UObject* result = _delegate->createFormat(loc, (UNumberFormatStyle)kind);
|
2004-08-24 17:38:33 +00:00
|
|
|
if (result == NULL) {
|
|
|
|
result = service->getKey((ICUServiceKey&)key /* cast away const */, NULL, this, status);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return NULL;
|
2003-02-25 23:36:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
2004-08-24 17:38:33 +00:00
|
|
|
/**
|
2010-01-28 19:39:24 +00:00
|
|
|
* Return the set of ids that this factory supports (visible or
|
2004-08-24 17:38:33 +00:00
|
|
|
* otherwise). This can be called often and might need to be
|
|
|
|
* cached if it is expensive to create.
|
|
|
|
*/
|
|
|
|
virtual const Hashtable* getSupportedIDs(UErrorCode& status) const
|
|
|
|
{
|
|
|
|
if (U_SUCCESS(status)) {
|
|
|
|
if (!_ids) {
|
|
|
|
int32_t count = 0;
|
|
|
|
const UnicodeString * const idlist = _delegate->getSupportedIDs(count, status);
|
|
|
|
((NFFactory*)this)->_ids = new Hashtable(status); /* cast away const */
|
|
|
|
if (_ids) {
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
|
|
_ids->put(idlist[i], (void*)this, status);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return _ids;
|
2003-02-27 20:14:51 +00:00
|
|
|
}
|
2004-08-24 17:38:33 +00:00
|
|
|
return NULL;
|
2003-02-25 23:36:48 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-07-26 05:32:25 +00:00
|
|
|
NFFactory::~NFFactory()
|
|
|
|
{
|
|
|
|
delete _delegate;
|
|
|
|
delete _ids;
|
|
|
|
}
|
|
|
|
|
2003-02-25 23:36:48 +00:00
|
|
|
class ICUNumberFormatService : public ICULocaleService {
|
|
|
|
public:
|
2004-08-24 17:38:33 +00:00
|
|
|
ICUNumberFormatService()
|
2005-03-09 23:50:26 +00:00
|
|
|
: ICULocaleService(UNICODE_STRING_SIMPLE("Number Format"))
|
2004-08-24 17:38:33 +00:00
|
|
|
{
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
registerFactory(new ICUNumberFormatFactory(), status);
|
|
|
|
}
|
2003-02-25 23:36:48 +00:00
|
|
|
|
2011-07-26 05:32:25 +00:00
|
|
|
virtual ~ICUNumberFormatService();
|
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
virtual UObject* cloneInstance(UObject* instance) const {
|
|
|
|
return ((NumberFormat*)instance)->clone();
|
|
|
|
}
|
2003-02-25 23:36:48 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /* actualID */, UErrorCode& status) const {
|
|
|
|
LocaleKey& lkey = (LocaleKey&)key;
|
|
|
|
int32_t kind = lkey.kind();
|
|
|
|
Locale loc;
|
|
|
|
lkey.currentLocale(loc);
|
2011-04-29 00:00:47 +00:00
|
|
|
return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status);
|
2004-08-24 17:38:33 +00:00
|
|
|
}
|
2003-02-25 23:36:48 +00:00
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
virtual UBool isDefault() const {
|
|
|
|
return countFactories() == 1;
|
|
|
|
}
|
2003-02-25 23:36:48 +00:00
|
|
|
};
|
|
|
|
|
2011-07-26 05:32:25 +00:00
|
|
|
ICUNumberFormatService::~ICUNumberFormatService() {}
|
|
|
|
|
2003-02-25 23:36:48 +00:00
|
|
|
// -------------------------------------
|
|
|
|
|
2013-05-31 23:50:15 +00:00
|
|
|
static void U_CALLCONV initNumberFormatService() {
|
|
|
|
U_ASSERT(gService == NULL);
|
|
|
|
ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup);
|
|
|
|
gService = new ICUNumberFormatService();
|
|
|
|
}
|
|
|
|
|
2010-01-28 19:39:24 +00:00
|
|
|
static ICULocaleService*
|
2004-04-08 23:24:45 +00:00
|
|
|
getNumberFormatService(void)
|
2003-02-25 23:36:48 +00:00
|
|
|
{
|
2013-05-31 23:50:15 +00:00
|
|
|
umtx_initOnce(gServiceInitOnce, &initNumberFormatService);
|
2003-05-13 23:12:37 +00:00
|
|
|
return gService;
|
2003-02-25 23:36:48 +00:00
|
|
|
}
|
|
|
|
|
2013-05-31 23:50:15 +00:00
|
|
|
static UBool haveService() {
|
|
|
|
return !gServiceInitOnce.isReset() && (getNumberFormatService() != NULL);
|
|
|
|
}
|
|
|
|
|
2003-02-25 23:36:48 +00:00
|
|
|
// -------------------------------------
|
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
URegistryKey U_EXPORT2
|
2003-02-25 23:36:48 +00:00
|
|
|
NumberFormat::registerFactory(NumberFormatFactory* toAdopt, UErrorCode& status)
|
|
|
|
{
|
2004-04-08 23:24:45 +00:00
|
|
|
ICULocaleService *service = getNumberFormatService();
|
2003-06-02 22:25:08 +00:00
|
|
|
if (service) {
|
2008-01-17 23:16:29 +00:00
|
|
|
NFFactory *tempnnf = new NFFactory(toAdopt);
|
|
|
|
if (tempnnf != NULL) {
|
|
|
|
return service->registerFactory(tempnnf, status);
|
|
|
|
}
|
2003-06-02 22:25:08 +00:00
|
|
|
}
|
|
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
|
|
return NULL;
|
2003-02-25 23:36:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------
|
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
UBool U_EXPORT2
|
2003-02-25 23:36:48 +00:00
|
|
|
NumberFormat::unregister(URegistryKey key, UErrorCode& status)
|
|
|
|
{
|
2013-05-31 23:50:15 +00:00
|
|
|
if (U_FAILURE(status)) {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (haveService()) {
|
|
|
|
return gService->unregister(key, status);
|
|
|
|
} else {
|
2003-06-09 20:06:55 +00:00
|
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
2013-05-31 23:50:15 +00:00
|
|
|
return FALSE;
|
2003-02-25 23:36:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------
|
2004-08-24 17:38:33 +00:00
|
|
|
StringEnumeration* U_EXPORT2
|
2003-02-25 23:36:48 +00:00
|
|
|
NumberFormat::getAvailableLocales(void)
|
|
|
|
{
|
2004-04-08 23:24:45 +00:00
|
|
|
ICULocaleService *service = getNumberFormatService();
|
2003-06-02 22:25:08 +00:00
|
|
|
if (service) {
|
2013-05-31 23:50:15 +00:00
|
|
|
return service->getAvailableLocales();
|
2003-06-02 22:25:08 +00:00
|
|
|
}
|
|
|
|
return NULL; // no way to return error condition
|
2003-02-25 23:36:48 +00:00
|
|
|
}
|
2004-07-18 01:37:13 +00:00
|
|
|
#endif /* UCONFIG_NO_SERVICE */
|
|
|
|
// -------------------------------------
|
|
|
|
|
2004-08-24 17:38:33 +00:00
|
|
|
NumberFormat* U_EXPORT2
|
2013-05-31 23:50:15 +00:00
|
|
|
NumberFormat::createInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) {
|
2004-07-18 01:37:13 +00:00
|
|
|
#if !UCONFIG_NO_SERVICE
|
2013-05-31 23:50:15 +00:00
|
|
|
if (haveService()) {
|
2004-07-18 01:37:13 +00:00
|
|
|
return (NumberFormat*)gService->get(loc, kind, status);
|
|
|
|
}
|
|
|
|
#endif
|
2013-05-31 23:50:15 +00:00
|
|
|
return makeInstance(loc, kind, status);
|
2004-07-18 01:37:13 +00:00
|
|
|
}
|
|
|
|
|
2003-02-25 23:36:48 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
2002-02-28 01:42:40 +00:00
|
|
|
// Checks if the thousand/10 thousand grouping is used in the
|
1999-08-16 21:50:52 +00:00
|
|
|
// NumberFormat instance.
|
|
|
|
|
2000-05-18 22:08:39 +00:00
|
|
|
UBool
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat::isGroupingUsed() const
|
|
|
|
{
|
|
|
|
return fGroupingUsed;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
2002-02-28 01:42:40 +00:00
|
|
|
// Sets to use the thousand/10 thousand grouping in the
|
1999-08-16 21:50:52 +00:00
|
|
|
// NumberFormat instance.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
void
|
2000-05-18 22:08:39 +00:00
|
|
|
NumberFormat::setGroupingUsed(UBool newValue)
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
|
|
|
fGroupingUsed = newValue;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Gets the maximum number of digits for the integral part for
|
|
|
|
// this NumberFormat instance.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
int32_t NumberFormat::getMaximumIntegerDigits() const
|
|
|
|
{
|
|
|
|
return fMaxIntegerDigits;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Sets the maximum number of digits for the integral part for
|
|
|
|
// this NumberFormat instance.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
void
|
|
|
|
NumberFormat::setMaximumIntegerDigits(int32_t newValue)
|
|
|
|
{
|
2013-09-17 21:56:23 +00:00
|
|
|
fMaxIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits));
|
1999-08-16 21:50:52 +00:00
|
|
|
if(fMinIntegerDigits > fMaxIntegerDigits)
|
|
|
|
fMinIntegerDigits = fMaxIntegerDigits;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Gets the minimum number of digits for the integral part for
|
|
|
|
// this NumberFormat instance.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
int32_t
|
|
|
|
NumberFormat::getMinimumIntegerDigits() const
|
|
|
|
{
|
|
|
|
return fMinIntegerDigits;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Sets the minimum number of digits for the integral part for
|
|
|
|
// this NumberFormat instance.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
void
|
|
|
|
NumberFormat::setMinimumIntegerDigits(int32_t newValue)
|
|
|
|
{
|
2013-09-17 21:56:23 +00:00
|
|
|
fMinIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits));
|
1999-08-16 21:50:52 +00:00
|
|
|
if(fMinIntegerDigits > fMaxIntegerDigits)
|
|
|
|
fMaxIntegerDigits = fMinIntegerDigits;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Gets the maximum number of digits for the fractional part for
|
|
|
|
// this NumberFormat instance.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
int32_t
|
|
|
|
NumberFormat::getMaximumFractionDigits() const
|
|
|
|
{
|
|
|
|
return fMaxFractionDigits;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Sets the maximum number of digits for the fractional part for
|
|
|
|
// this NumberFormat instance.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
void
|
|
|
|
NumberFormat::setMaximumFractionDigits(int32_t newValue)
|
|
|
|
{
|
2013-09-17 21:56:23 +00:00
|
|
|
fMaxFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits));
|
1999-08-16 21:50:52 +00:00
|
|
|
if(fMaxFractionDigits < fMinFractionDigits)
|
|
|
|
fMinFractionDigits = fMaxFractionDigits;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Gets the minimum number of digits for the fractional part for
|
|
|
|
// this NumberFormat instance.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
int32_t
|
|
|
|
NumberFormat::getMinimumFractionDigits() const
|
|
|
|
{
|
|
|
|
return fMinFractionDigits;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Sets the minimum number of digits for the fractional part for
|
|
|
|
// this NumberFormat instance.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
void
|
|
|
|
NumberFormat::setMinimumFractionDigits(int32_t newValue)
|
|
|
|
{
|
2013-09-17 21:56:23 +00:00
|
|
|
fMinFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits));
|
1999-08-16 21:50:52 +00:00
|
|
|
if (fMaxFractionDigits < fMinFractionDigits)
|
|
|
|
fMaxFractionDigits = fMinFractionDigits;
|
|
|
|
}
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2003-04-24 22:58:04 +00:00
|
|
|
// -------------------------------------
|
|
|
|
|
2004-02-13 01:51:42 +00:00
|
|
|
void NumberFormat::setCurrency(const UChar* theCurrency, UErrorCode& ec) {
|
|
|
|
if (U_FAILURE(ec)) {
|
|
|
|
return;
|
|
|
|
}
|
2003-04-24 22:58:04 +00:00
|
|
|
if (theCurrency) {
|
2004-02-13 01:51:42 +00:00
|
|
|
u_strncpy(fCurrency, theCurrency, 3);
|
|
|
|
fCurrency[3] = 0;
|
2003-04-24 22:58:04 +00:00
|
|
|
} else {
|
2004-02-13 01:51:42 +00:00
|
|
|
fCurrency[0] = 0;
|
2003-04-24 22:58:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const UChar* NumberFormat::getCurrency() const {
|
2004-02-13 01:51:42 +00:00
|
|
|
return fCurrency;
|
2003-04-24 22:58:04 +00:00
|
|
|
}
|
|
|
|
|
2004-04-15 06:20:42 +00:00
|
|
|
void NumberFormat::getEffectiveCurrency(UChar* result, UErrorCode& ec) const {
|
|
|
|
const UChar* c = getCurrency();
|
|
|
|
if (*c != 0) {
|
|
|
|
u_strncpy(result, c, 3);
|
|
|
|
result[3] = 0;
|
|
|
|
} else {
|
|
|
|
const char* loc = getLocaleID(ULOC_VALID_LOCALE, ec);
|
|
|
|
if (loc == NULL) {
|
|
|
|
loc = uloc_getDefault();
|
|
|
|
}
|
|
|
|
ucurr_forLocale(loc, result, 4, &ec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-14 07:31:30 +00:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
void NumberFormat::setContext(UDisplayContext value, UErrorCode& status)
|
|
|
|
{
|
|
|
|
if (U_FAILURE(status))
|
|
|
|
return;
|
|
|
|
if ( (UDisplayContextType)((uint32_t)value >> 8) == UDISPCTX_TYPE_CAPITALIZATION ) {
|
|
|
|
fCapitalizationContext = value;
|
|
|
|
} else {
|
|
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
UDisplayContext NumberFormat::getContext(UDisplayContextType type, UErrorCode& status) const
|
|
|
|
{
|
|
|
|
if (U_FAILURE(status))
|
|
|
|
return (UDisplayContext)0;
|
|
|
|
if (type != UDISPCTX_TYPE_CAPITALIZATION) {
|
|
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
|
|
return (UDisplayContext)0;
|
|
|
|
}
|
|
|
|
return fCapitalizationContext;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
// -------------------------------------
|
|
|
|
// Creates the NumberFormat instance of the specified style (number, currency,
|
|
|
|
// or percent) for the desired locale.
|
2002-02-28 01:42:40 +00:00
|
|
|
|
2013-05-31 23:50:15 +00:00
|
|
|
static void U_CALLCONV nscacheInit() {
|
|
|
|
U_ASSERT(NumberingSystem_cache == NULL);
|
|
|
|
ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup);
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
NumberingSystem_cache = uhash_open(uhash_hashLong,
|
|
|
|
uhash_compareLong,
|
|
|
|
NULL,
|
|
|
|
&status);
|
|
|
|
if (U_FAILURE(status)) {
|
|
|
|
// Number Format code will run with no cache if creation fails.
|
|
|
|
NumberingSystem_cache = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
uhash_setValueDeleter(NumberingSystem_cache, deleteNumberingSystem);
|
|
|
|
}
|
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
UBool
|
|
|
|
NumberFormat::isStyleSupported(UNumberFormatStyle style) {
|
|
|
|
return gLastResortNumberPatterns[style] != NULL;
|
|
|
|
}
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
NumberFormat*
|
2003-02-25 23:36:48 +00:00
|
|
|
NumberFormat::makeInstance(const Locale& desiredLocale,
|
2011-04-29 00:00:47 +00:00
|
|
|
UNumberFormatStyle style,
|
2012-11-14 18:49:38 +00:00
|
|
|
UErrorCode& status) {
|
|
|
|
return makeInstance(desiredLocale, style, false, status);
|
|
|
|
}
|
|
|
|
|
|
|
|
NumberFormat*
|
|
|
|
NumberFormat::makeInstance(const Locale& desiredLocale,
|
|
|
|
UNumberFormatStyle style,
|
|
|
|
UBool mustBeDecimalFormat,
|
|
|
|
UErrorCode& status) {
|
1999-10-18 22:48:32 +00:00
|
|
|
if (U_FAILURE(status)) return NULL;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
if (style < 0 || style >= UNUM_FORMAT_STYLE_COUNT) {
|
1999-10-07 00:07:53 +00:00
|
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
1999-08-16 21:50:52 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
// Some styles are not supported. This is a result of merging
|
|
|
|
// the @draft ICU 4.2 NumberFormat::EStyles into the long-existing UNumberFormatStyle.
|
|
|
|
// Ticket #8503 is for reviewing/fixing/merging the two relevant implementations:
|
|
|
|
// this one and unum_open().
|
|
|
|
// The UNUM_PATTERN_ styles are not supported here
|
|
|
|
// because this method does not take a pattern string.
|
|
|
|
if (!isStyleSupported(style)) {
|
|
|
|
status = U_UNSUPPORTED_ERROR;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-08-18 18:47:16 +00:00
|
|
|
#if U_PLATFORM_USES_ONLY_WIN32_API
|
2012-11-14 18:49:38 +00:00
|
|
|
if (!mustBeDecimalFormat) {
|
|
|
|
char buffer[8];
|
|
|
|
int32_t count = desiredLocale.getKeywordValue("compat", buffer, sizeof(buffer), status);
|
|
|
|
|
|
|
|
// if the locale has "@compat=host", create a host-specific NumberFormat
|
|
|
|
if (U_SUCCESS(status) && count > 0 && uprv_strcmp(buffer, "host") == 0) {
|
|
|
|
Win32NumberFormat *f = NULL;
|
|
|
|
UBool curr = TRUE;
|
|
|
|
|
|
|
|
switch (style) {
|
|
|
|
case UNUM_DECIMAL:
|
|
|
|
curr = FALSE;
|
|
|
|
// fall-through
|
|
|
|
|
|
|
|
case UNUM_CURRENCY:
|
|
|
|
case UNUM_CURRENCY_ISO: // do not support plural formatting here
|
|
|
|
case UNUM_CURRENCY_PLURAL:
|
|
|
|
f = new Win32NumberFormat(desiredLocale, curr, status);
|
|
|
|
|
|
|
|
if (U_SUCCESS(status)) {
|
|
|
|
return f;
|
|
|
|
}
|
2010-01-28 19:39:24 +00:00
|
|
|
|
2012-11-14 18:49:38 +00:00
|
|
|
delete f;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2006-01-12 19:53:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2010-01-28 19:39:24 +00:00
|
|
|
// Use numbering system cache hashtable
|
2013-05-31 23:50:15 +00:00
|
|
|
umtx_initOnce(gNSCacheInitOnce, &nscacheInit);
|
2010-01-28 19:39:24 +00:00
|
|
|
|
|
|
|
// Get cached numbering system
|
2011-04-29 00:00:47 +00:00
|
|
|
LocalPointer<NumberingSystem> ownedNs;
|
|
|
|
NumberingSystem *ns = NULL;
|
2013-05-31 23:50:15 +00:00
|
|
|
if (NumberingSystem_cache != NULL) {
|
2011-04-29 00:00:47 +00:00
|
|
|
// TODO: Bad hash key usage, see ticket #8504.
|
|
|
|
int32_t hashKey = desiredLocale.hashCode();
|
2010-01-28 19:39:24 +00:00
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
Mutex lock(&nscacheMutex);
|
2013-05-31 23:50:15 +00:00
|
|
|
ns = (NumberingSystem *)uhash_iget(NumberingSystem_cache, hashKey);
|
2010-01-28 19:39:24 +00:00
|
|
|
if (ns == NULL) {
|
|
|
|
ns = NumberingSystem::createInstance(desiredLocale,status);
|
2013-05-31 23:50:15 +00:00
|
|
|
uhash_iput(NumberingSystem_cache, hashKey, (void*)ns, &status);
|
2010-01-28 19:39:24 +00:00
|
|
|
}
|
2011-04-29 00:00:47 +00:00
|
|
|
} else {
|
|
|
|
ownedNs.adoptInstead(NumberingSystem::createInstance(desiredLocale,status));
|
|
|
|
ns = ownedNs.getAlias();
|
2010-01-28 19:39:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// check results of getting a numbering system
|
2011-04-29 00:00:47 +00:00
|
|
|
if (U_FAILURE(status)) {
|
|
|
|
return NULL;
|
2001-06-26 02:07:54 +00:00
|
|
|
}
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2012-11-14 18:49:38 +00:00
|
|
|
if (mustBeDecimalFormat && ns->isAlgorithmic()) {
|
|
|
|
status = U_UNSUPPORTED_ERROR;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-08-24 18:06:46 +00:00
|
|
|
LocalPointer<DecimalFormatSymbols> symbolsToAdopt;
|
|
|
|
UnicodeString pattern;
|
|
|
|
LocalUResourceBundlePointer ownedResource(ures_open(NULL, desiredLocale.getName(), &status));
|
|
|
|
if (U_FAILURE(status)) {
|
|
|
|
// We don't appear to have resource data available -- use the last-resort data
|
|
|
|
status = U_USING_FALLBACK_WARNING;
|
|
|
|
// When the data is unavailable, and locale isn't passed in, last resort data is used.
|
|
|
|
symbolsToAdopt.adoptInstead(new DecimalFormatSymbols(status));
|
|
|
|
if (symbolsToAdopt.isNull()) {
|
|
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Creates a DecimalFormat instance with the last resort number patterns.
|
|
|
|
pattern.setTo(TRUE, gLastResortNumberPatterns[style], -1);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Loads the decimal symbols of the desired locale.
|
|
|
|
symbolsToAdopt.adoptInstead(new DecimalFormatSymbols(desiredLocale, status));
|
|
|
|
if (symbolsToAdopt.isNull()) {
|
|
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
UResourceBundle *resource = ownedResource.orphan();
|
|
|
|
UResourceBundle *numElements = ures_getByKeyWithFallback(resource, gNumberElements, NULL, &status);
|
|
|
|
resource = ures_getByKeyWithFallback(numElements, ns->getName(), resource, &status);
|
|
|
|
resource = ures_getByKeyWithFallback(resource, gPatterns, resource, &status);
|
|
|
|
ownedResource.adoptInstead(resource);
|
|
|
|
|
|
|
|
int32_t patLen = 0;
|
|
|
|
const UChar *patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[style], &patLen, &status);
|
|
|
|
|
|
|
|
// Didn't find a pattern specific to the numbering system, so fall back to "latn"
|
|
|
|
if ( status == U_MISSING_RESOURCE_ERROR && uprv_strcmp(gLatn,ns->getName())) {
|
|
|
|
status = U_ZERO_ERROR;
|
|
|
|
resource = ures_getByKeyWithFallback(numElements, gLatn, resource, &status);
|
|
|
|
resource = ures_getByKeyWithFallback(resource, gPatterns, resource, &status);
|
|
|
|
patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[style], &patLen, &status);
|
|
|
|
}
|
|
|
|
|
2011-08-30 03:22:38 +00:00
|
|
|
ures_close(numElements);
|
|
|
|
|
2011-08-24 18:06:46 +00:00
|
|
|
// Creates the specified decimal format style of the desired locale.
|
|
|
|
pattern.setTo(TRUE, patResStr, patLen);
|
|
|
|
}
|
|
|
|
if (U_FAILURE(status)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if(style==UNUM_CURRENCY || style == UNUM_CURRENCY_ISO){
|
|
|
|
const UChar* currPattern = symbolsToAdopt->getCurrencyPattern();
|
|
|
|
if(currPattern!=NULL){
|
|
|
|
pattern.setTo(currPattern, u_strlen(currPattern));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
NumberFormat *f;
|
2009-01-22 04:46:35 +00:00
|
|
|
if (ns->isAlgorithmic()) {
|
2009-02-23 22:41:41 +00:00
|
|
|
UnicodeString nsDesc;
|
|
|
|
UnicodeString nsRuleSetGroup;
|
|
|
|
UnicodeString nsRuleSetName;
|
|
|
|
Locale nsLoc;
|
|
|
|
URBNFRuleSetTag desiredRulesType = URBNF_NUMBERING_SYSTEM;
|
2010-01-28 19:39:24 +00:00
|
|
|
|
2009-02-23 22:41:41 +00:00
|
|
|
nsDesc.setTo(ns->getDescription());
|
|
|
|
int32_t firstSlash = nsDesc.indexOf(gSlash);
|
|
|
|
int32_t lastSlash = nsDesc.lastIndexOf(gSlash);
|
|
|
|
if ( lastSlash > firstSlash ) {
|
2011-04-29 00:00:47 +00:00
|
|
|
CharString nsLocID;
|
2009-02-23 22:41:41 +00:00
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
nsLocID.appendInvariantChars(nsDesc.tempSubString(0, firstSlash), status);
|
2009-02-23 22:41:41 +00:00
|
|
|
nsRuleSetGroup.setTo(nsDesc,firstSlash+1,lastSlash-firstSlash-1);
|
|
|
|
nsRuleSetName.setTo(nsDesc,lastSlash+1);
|
2010-01-28 19:39:24 +00:00
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
nsLoc = Locale::createFromName(nsLocID.data());
|
2009-02-23 22:41:41 +00:00
|
|
|
|
|
|
|
UnicodeString SpelloutRules = UNICODE_STRING_SIMPLE("SpelloutRules");
|
|
|
|
if ( nsRuleSetGroup.compare(SpelloutRules) == 0 ) {
|
|
|
|
desiredRulesType = URBNF_SPELLOUT;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
nsLoc = desiredLocale;
|
|
|
|
nsRuleSetName.setTo(nsDesc);
|
|
|
|
}
|
|
|
|
|
|
|
|
RuleBasedNumberFormat *r = new RuleBasedNumberFormat(desiredRulesType,nsLoc,status);
|
2011-04-29 00:00:47 +00:00
|
|
|
if (r == NULL) {
|
|
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
|
|
return NULL;
|
2009-01-22 04:46:35 +00:00
|
|
|
}
|
2009-02-23 22:41:41 +00:00
|
|
|
r->setDefaultRuleSet(nsRuleSetName,status);
|
2011-04-29 00:00:47 +00:00
|
|
|
f = r;
|
2009-01-22 04:46:35 +00:00
|
|
|
} else {
|
2009-02-12 22:55:29 +00:00
|
|
|
// replace single currency sign in the pattern with double currency sign
|
2011-04-29 00:00:47 +00:00
|
|
|
// if the style is UNUM_CURRENCY_ISO
|
|
|
|
if (style == UNUM_CURRENCY_ISO) {
|
2011-07-07 18:46:19 +00:00
|
|
|
pattern.findAndReplace(UnicodeString(TRUE, gSingleCurrencySign, 1),
|
|
|
|
UnicodeString(TRUE, gDoubleCurrencySign, 2));
|
2009-02-12 22:55:29 +00:00
|
|
|
}
|
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
// "new DecimalFormat()" does not adopt the symbols if its memory allocation fails.
|
|
|
|
DecimalFormatSymbols *syms = symbolsToAdopt.orphan();
|
|
|
|
f = new DecimalFormat(pattern, syms, style, status);
|
|
|
|
if (f == NULL) {
|
|
|
|
delete syms;
|
|
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
|
|
return NULL;
|
2009-02-12 22:55:29 +00:00
|
|
|
}
|
2009-07-29 22:13:15 +00:00
|
|
|
}
|
2010-01-28 19:39:24 +00:00
|
|
|
|
2011-04-29 00:00:47 +00:00
|
|
|
f->setLocaleIDs(ures_getLocaleByType(ownedResource.getAlias(), ULOC_VALID_LOCALE, &status),
|
|
|
|
ures_getLocaleByType(ownedResource.getAlias(), ULOC_ACTUAL_LOCALE, &status));
|
2004-09-02 19:08:28 +00:00
|
|
|
if (U_FAILURE(status)) {
|
2011-04-29 00:00:47 +00:00
|
|
|
delete f;
|
2001-06-26 02:07:54 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
1999-08-16 21:50:52 +00:00
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2001-10-08 23:26:58 +00:00
|
|
|
U_NAMESPACE_END
|
|
|
|
|
2002-09-20 01:54:48 +00:00
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
//eof
|