#include "unicode/utypes.h"
#if !UCONFIG_NO_FORMATTING
#include "unicode/numfmt.h"
#include "unicode/locid.h"
#include "unicode/resbund.h"
#include "unicode/dcfmtsym.h"
#include "unicode/decimfmt.h"
#include "unicode/ustring.h"
#include "uhash.h"
#include "iculserv.h"
#include "ucln_in.h"
#include <float.h>
static const UChar gLastResortDecimalPat[] = {
0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0x3B, 0x2D, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0
};
static const UChar gLastResortCurrencyPat[] = {
0x24, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x3B, 0x28, 0x24, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x29, 0
};
static const UChar gLastResortPercentPat[] = {
0x23, 0x30, 0x25, 0
};
static const UChar gLastResortScientificPat[] = {
0x23, 0x45, 0x30, 0
};
U_NAMESPACE_BEGIN
const char NumberFormat::fgClassID = 0;
const int32_t NumberFormat::fgMaxIntegerDigits = DBL_MAX_10_EXP + 1; const int32_t NumberFormat::fgMinIntegerDigits = 127;
const int32_t NumberFormat::fgNumberPatternsCount = 3;
const UChar * const NumberFormat::fgLastResortNumberPatterns[] =
{
gLastResortDecimalPat,
gLastResortCurrencyPat,
gLastResortPercentPat,
gLastResortScientificPat
};
NumberFormat::NumberFormat()
: fGroupingUsed(TRUE),
fMaxIntegerDigits(fgMaxIntegerDigits),
fMinIntegerDigits(1),
fMaxFractionDigits(3), fMinFractionDigits(0),
fParseIntegerOnly(FALSE)
{
}
NumberFormat::~NumberFormat()
{
}
NumberFormat::NumberFormat(const NumberFormat &source)
: Format(source)
{
*this = source;
}
NumberFormat&
NumberFormat::operator=(const NumberFormat& rhs)
{
if (this != &rhs)
{
fGroupingUsed = rhs.fGroupingUsed;
fMaxIntegerDigits = rhs.fMaxIntegerDigits;
fMinIntegerDigits = rhs.fMinIntegerDigits;
fMaxFractionDigits = rhs.fMaxFractionDigits;
fMinFractionDigits = rhs.fMinFractionDigits;
fParseIntegerOnly = rhs.fParseIntegerOnly;
}
return *this;
}
UBool
NumberFormat::operator==(const Format& that) const
{
NumberFormat* other = (NumberFormat*)&that;
return ((this == &that) ||
((Format::operator==(that) &&
getDynamicClassID()== that.getDynamicClassID() &&
fMaxIntegerDigits == other->fMaxIntegerDigits &&
fMinIntegerDigits == other->fMinIntegerDigits &&
fMaxFractionDigits == other->fMaxFractionDigits &&
fMinFractionDigits == other->fMinFractionDigits &&
fGroupingUsed == other->fGroupingUsed &&
fParseIntegerOnly == other->fParseIntegerOnly)));
}
UnicodeString&
NumberFormat::format(const Formattable& obj,
UnicodeString& appendTo,
FieldPosition& pos,
UErrorCode& status) const
{
if (U_FAILURE(status)) return appendTo;
if (obj.getType() == Formattable::kDouble) {
return format(obj.getDouble(), appendTo, pos);
}
else if (obj.getType() == Formattable::kLong) {
return format(obj.getLong(), appendTo, pos);
}
else {
status = U_INVALID_FORMAT_ERROR;
return appendTo;
}
}
void
NumberFormat::parseObject(const UnicodeString& source,
Formattable& result,
ParsePosition& parse_pos) const
{
parse(source, result, parse_pos);
}
UnicodeString&
NumberFormat::format(double number, UnicodeString& appendTo) const
{
FieldPosition pos(0);
return format(number, appendTo, pos);
}
UnicodeString&
NumberFormat::format(int32_t number, UnicodeString& appendTo) const
{
FieldPosition pos(0);
return format(number, appendTo, pos);
}
void
NumberFormat::parse(const UnicodeString& text,
Formattable& result,
UErrorCode& status) const
{
if (U_FAILURE(status)) return;
ParsePosition parsePosition(0);
parse(text, result, parsePosition);
if (parsePosition.getIndex() == 0) {
status = U_INVALID_FORMAT_ERROR;
}
}
void
NumberFormat::setParseIntegerOnly(UBool value)
{
fParseIntegerOnly = value;
}
NumberFormat*
NumberFormat::createInstance(UErrorCode& status)
{
return createInstance(Locale::getDefault(), kNumberStyle, status);
}
NumberFormat*
NumberFormat::createInstance(const Locale& inLocale, UErrorCode& status)
{
return createInstance(inLocale, kNumberStyle, status);
}
NumberFormat*
NumberFormat::createCurrencyInstance(UErrorCode& status)
{
return createInstance(Locale::getDefault(), kCurrencyStyle, status);
}
NumberFormat*
NumberFormat::createCurrencyInstance(const Locale& inLocale, UErrorCode& status)
{
return createInstance(inLocale, kCurrencyStyle, status);
}
NumberFormat*
NumberFormat::createPercentInstance(UErrorCode& status)
{
return createInstance(Locale::getDefault(), kPercentStyle, status);
}
NumberFormat*
NumberFormat::createPercentInstance(const Locale& inLocale, UErrorCode& status)
{
return createInstance(inLocale, kPercentStyle, status);
}
NumberFormat*
NumberFormat::createScientificInstance(UErrorCode& status)
{
return createInstance(Locale::getDefault(), kScientificStyle, status);
}
NumberFormat*
NumberFormat::createScientificInstance(const Locale& inLocale, UErrorCode& status)
{
return createInstance(inLocale, kScientificStyle, status);
}
const Locale*
NumberFormat::getAvailableLocales(int32_t& count)
{
return Locale::getAvailableLocales(count);
}
static ICULocaleService* gService = NULL;
class ICUNumberFormatFactory : public ICUResourceBundleFactory {
protected:
virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* service, UErrorCode& status) const {
return NumberFormat::makeInstance(loc, (NumberFormat::EStyles)kind, status);
}
};
class NFFactory : public LocaleKeyFactory {
private:
NumberFormatFactory* _delegate;
Hashtable* _ids;
public:
NFFactory(NumberFormatFactory* delegate)
: LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE)
, _delegate(delegate)
, _ids(NULL)
{
}
virtual ~NFFactory()
{
delete _delegate;
delete _ids;
}
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();
UObject* result = _delegate->createFormat(loc, (UNumberFormatStyle)(kind+1));
if (result == NULL) {
result = service->getKey((ICUServiceKey&)key , NULL, this, status);
}
return result;
}
return NULL;
}
protected:
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);
if (_ids) {
for (int i = 0; i < count; ++i) {
_ids->put(idlist[i], (void*)this, status);
}
}
}
return _ids;
}
return NULL;
}
};
class ICUNumberFormatService : public ICULocaleService {
public:
ICUNumberFormatService()
: ICULocaleService("Number Format")
{
UErrorCode status = U_ZERO_ERROR;
registerFactory(new ICUNumberFormatFactory(), status);
}
virtual UObject* cloneInstance(UObject* instance) const {
return ((NumberFormat*)instance)->clone();
}
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);
return NumberFormat::makeInstance(loc, (NumberFormat::EStyles)kind, status);
}
virtual UBool isDefault() const {
return countFactories() == 1;
}
};
static ICULocaleService*
getService(void)
{
UBool needInit;
{
Mutex mutex;
needInit = (UBool)(gService == NULL);
}
if (needInit) {
ICULocaleService * newservice = new ICUNumberFormatService();
if (newservice) {
Mutex mutex;
if (gService == NULL) {
gService = newservice;
newservice = NULL;
}
}
if (newservice) {
delete newservice;
} else {
ucln_i18n_registerCleanup();
}
}
return gService;
}
NumberFormat*
NumberFormat::createInstance(const Locale& loc, EStyles kind, UErrorCode& status)
{
umtx_lock(NULL);
UBool haveService = gService != NULL;
umtx_unlock(NULL);
if (haveService) {
return (NumberFormat*)gService->get(loc, kind, status);
} else {
return makeInstance(loc, kind, status);
}
}
URegistryKey
NumberFormat::registerFactory(NumberFormatFactory* toAdopt, UErrorCode& status)
{
ICULocaleService *service = getService();
if (service) {
return service->registerFactory(new NFFactory(toAdopt), status);
}
status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
UBool
NumberFormat::unregister(URegistryKey key, UErrorCode& status)
{
if (U_SUCCESS(status)) {
umtx_lock(NULL);
UBool haveService = gService != NULL;
umtx_unlock(NULL);
if (haveService) {
return gService->unregister(key, status);
}
status = U_ILLEGAL_ARGUMENT_ERROR;
}
return FALSE;
}
StringEnumeration*
NumberFormat::getAvailableLocales(void)
{
ICULocaleService *service = getService();
if (service) {
return service->getAvailableLocales();
}
return NULL; }
UBool
NumberFormat::isGroupingUsed() const
{
return fGroupingUsed;
}
void
NumberFormat::setGroupingUsed(UBool newValue)
{
fGroupingUsed = newValue;
}
int32_t NumberFormat::getMaximumIntegerDigits() const
{
return fMaxIntegerDigits;
}
void
NumberFormat::setMaximumIntegerDigits(int32_t newValue)
{
fMaxIntegerDigits = uprv_max(0, uprv_min(newValue, fgMaxIntegerDigits));
if(fMinIntegerDigits > fMaxIntegerDigits)
fMinIntegerDigits = fMaxIntegerDigits;
}
int32_t
NumberFormat::getMinimumIntegerDigits() const
{
return fMinIntegerDigits;
}
void
NumberFormat::setMinimumIntegerDigits(int32_t newValue)
{
fMinIntegerDigits = uprv_max(0, uprv_min(newValue, fgMinIntegerDigits));
if(fMinIntegerDigits > fMaxIntegerDigits)
fMaxIntegerDigits = fMinIntegerDigits;
}
int32_t
NumberFormat::getMaximumFractionDigits() const
{
return fMaxFractionDigits;
}
void
NumberFormat::setMaximumFractionDigits(int32_t newValue)
{
fMaxFractionDigits = uprv_max(0, uprv_min(newValue, fgMaxIntegerDigits));
if(fMaxFractionDigits < fMinFractionDigits)
fMinFractionDigits = fMaxFractionDigits;
}
int32_t
NumberFormat::getMinimumFractionDigits() const
{
return fMinFractionDigits;
}
void
NumberFormat::setMinimumFractionDigits(int32_t newValue)
{
fMinFractionDigits = uprv_max(0, uprv_min(newValue, fgMinIntegerDigits));
if (fMaxFractionDigits < fMinFractionDigits)
fMaxFractionDigits = fMinFractionDigits;
}
void NumberFormat::setCurrency(const UChar* theCurrency) {
if (theCurrency) {
u_strncpy(currency, theCurrency, 3);
currency[3] = 0;
} else {
currency[0] = 0;
}
}
const UChar* NumberFormat::getCurrency() const {
return currency;
}
NumberFormat*
NumberFormat::makeInstance(const Locale& desiredLocale,
EStyles style,
UErrorCode& status)
{
if (U_FAILURE(status)) return NULL;
if (style < 0 || style >= kStyleCount) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
ResourceBundle resource((char *)0, desiredLocale, status);
NumberFormat* f;
if (U_FAILURE(status))
{
status = U_USING_FALLBACK_WARNING;
DecimalFormatSymbols* symbolsToAdopt = new DecimalFormatSymbols(status);
if (symbolsToAdopt == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
if (U_FAILURE(status)) {
delete symbolsToAdopt; return NULL;
}
f = new DecimalFormat(fgLastResortNumberPatterns[style], symbolsToAdopt, status);
if (f == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
if (U_FAILURE(status)) {
delete f;
f = NULL;
}
return f;
}
ResourceBundle numberPatterns(resource.get(DecimalFormat::fgNumberPatterns, status));
if (numberPatterns.getSize() < fgNumberPatternsCount)
status = U_INVALID_FORMAT_ERROR;
if (U_FAILURE(status))
return NULL;
DecimalFormatSymbols* symbolsToAdopt = new DecimalFormatSymbols(desiredLocale, status);
if (symbolsToAdopt == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
if (U_FAILURE(status)) {
delete symbolsToAdopt;
return NULL;
}
if (style < numberPatterns.getSize()) {
const UnicodeString pattern(numberPatterns.getStringEx(style, status));
if (U_SUCCESS(status)) {
f = new DecimalFormat(pattern, symbolsToAdopt, status);
}
else {
return NULL;
}
}
else {
f = new DecimalFormat(fgLastResortNumberPatterns[style], symbolsToAdopt, status);
}
if (f == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
if (U_FAILURE(status)) {
delete f;
f = NULL;
}
return f;
}
U_NAMESPACE_END
U_CFUNC UBool numfmt_cleanup(void) {
if (gService) {
delete gService;
gService = NULL;
}
return TRUE;
}
#endif