static jstring NativeDecimalFormat_toPatternImpl(JNIEnv* env, jclass, jlong addr, jboolean localized) {
DecimalFormat* fmt = toDecimalFormat(addr);
UnicodeString pattern;
if (localized) {
fmt->toLocalizedPattern(pattern);
} else {
fmt->toPattern(pattern);
}
return env->NewString(pattern.getBuffer(), pattern.length());
}
//static jstring NativeDecimalFormat_toPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized) {
JNIEXPORT jstring JNICALL
Java_com_ibm_icu4jni_text_NativeDecimalFormat_toPatternImpl(JNIEnv* env,
jclass, jint addr, jboolean localized) {
DecimalFormat* fmt = toDecimalFormat(addr);
UnicodeString pattern;
if (localized) {
fmt->toLocalizedPattern(pattern);
} else {
fmt->toPattern(pattern);
}
return env->NewString((const jchar*) pattern.getBuffer(), pattern.length());
}
std::string GlobalizationNDK::getNumberPattern(const std::string& args)
{
// This is the default value when no options provided.
ENumberType type = kNumberDecimal;
if (!args.empty()) {
Json::Reader reader;
Json::Value root;
bool parse = reader.parse(args, root);
if (!parse) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getNumberPattern: invalid json data: %s",
args.c_str());
return errorInJson(PARSING_ERROR, "Invalid json data!");
}
Json::Value options = root["options"];
std::string error;
if (!handleNumberOptions(options, type, error))
return errorInJson(PARSING_ERROR, error);
}
std::string pattern, symbol, positive, negative, decimal, grouping;
int fraction;
double rounding;
UErrorCode status = U_ZERO_ERROR;
NumberFormat* nf;
switch (type) {
case kNumberDecimal:
default:
nf = NumberFormat::createInstance(status);
break;
case kNumberCurrency:
nf = NumberFormat::createCurrencyInstance(status);
break;
case kNumberPercent:
nf = NumberFormat::createPercentInstance(status);
break;
}
if (!nf) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getNumberPattern: failed to create NumberFormat instance for type %d: %d",
status, type);
return errorInJson(UNKNOWN_ERROR, "Failed to create NumberFormat instance!");
}
std::auto_ptr<NumberFormat> deleter(nf);
if (nf->getDynamicClassID() != DecimalFormat::getStaticClassID()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getNumberPattern: DecimalFormat expected: %p != %p",
nf->getDynamicClassID(), DecimalFormat::getStaticClassID());
return errorInJson(UNKNOWN_ERROR, "DecimalFormat expected!");
}
DecimalFormat* df = (DecimalFormat*) nf;
const DecimalFormatSymbols* dfs = df->getDecimalFormatSymbols();
if (!dfs) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getNumberPattern: unable to get DecimalFormatSymbols!");
return errorInJson(UNKNOWN_ERROR, "Failed to get DecimalFormatSymbols instance!");
}
UnicodeString ucs;
df->toPattern(ucs);
ucs.toUTF8String(pattern);
ucs.remove();
df->getPositivePrefix(ucs);
if (ucs.isEmpty())
df->getPositiveSuffix(ucs);
ucs.toUTF8String(positive);
ucs.remove();
df->getNegativePrefix(ucs);
if (ucs.isEmpty())
df->getNegativeSuffix(ucs);
ucs.toUTF8String(negative);
ucs.remove();
rounding = df->getRoundingIncrement();
fraction = df->getMaximumFractionDigits();
ucs = dfs->getSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol);
ucs.toUTF8String(decimal);
ucs.remove();
ucs = dfs->getSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol);
ucs.toUTF8String(grouping);
ucs.remove();
if (type == kNumberPercent)
ucs = dfs->getSymbol(DecimalFormatSymbols::kPercentSymbol);
else if (type == kNumberCurrency)
ucs = dfs->getSymbol(DecimalFormatSymbols::kCurrencySymbol);
else
ucs = dfs->getSymbol(DecimalFormatSymbols::kDigitSymbol);
ucs.toUTF8String(symbol);
ucs.remove();
return resultInJson(pattern, symbol, fraction, rounding, positive, negative, decimal, grouping);
}
std::string GlobalizationNDK::getCurrencyPattern(const std::string& args)
{
if (args.empty()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getCurrencyPattern: no arguments provided!");
return errorInJson(UNKNOWN_ERROR, "No arguments provided!");
}
Json::Reader reader;
Json::Value root;
bool parse = reader.parse(args, root);
if (!parse) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getCurrencyPattern: invalid json data: %s",
args.c_str());
return errorInJson(PARSING_ERROR, "Invalid json data!");
}
Json::Value ccv = root["currencyCode"];
if (ccv.isNull()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getCurrencyPattern: no currencyCode provided!");
return errorInJson(FORMATTING_ERROR, "No currencyCode provided!");
}
if (!ccv.isString()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getCurrencyPattern: invalid currencyCode type: %d!",
ccv.type());
return errorInJson(FORMATTING_ERROR, "Invalid currencyCode type!");
}
std::string cc = ccv.asString();
if (cc.empty()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getCurrencyPattern: empty currencyCode!");
return errorInJson(FORMATTING_ERROR, "Empty currencyCode!");
}
UnicodeString ucc = UnicodeString::fromUTF8(cc);
DecimalFormat* df = 0;
int count = 0;
const Locale* locs = Locale::getAvailableLocales(count);
for (int i = 0; i < count; ++i) {
UErrorCode status = U_ZERO_ERROR;
NumberFormat* nf = NumberFormat::createCurrencyInstance(*(locs + i), status);
if (!nf) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getCurrencyPattern: locale %d: unable to get NumberFormat instance!",
i);
continue;
}
std::auto_ptr<NumberFormat> ndeleter(nf);
const UChar* currency = nf->getCurrency();
if (!currency) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getCurrencyPattern: locale %d: failed to getCurrency!",
i);
continue;
}
if (!ucc.compare(currency, -1)) {
df = (DecimalFormat*) ndeleter.release();
break;
}
}
if (!df)
return errorInJson(UNKNOWN_ERROR, "Currency not supported!");
std::auto_ptr<DecimalFormat> deleter(df);
const DecimalFormatSymbols* dfs = df->getDecimalFormatSymbols();
if (!dfs) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getCurrencyPattern: unable to get DecimalFormatSymbols!");
return errorInJson(UNKNOWN_ERROR, "Failed to get DecimalFormatSymbols!");
}
UnicodeString ucs;
std::string pattern;
df->toPattern(ucs);
ucs.toUTF8String(pattern);
ucs.remove();
int fraction = df->getMaximumFractionDigits();
double rounding = df->getRoundingIncrement();
std::string decimal;
ucs = dfs->getSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol);
ucs.toUTF8String(decimal);
ucs.remove();
std::string grouping;
ucs = dfs->getSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol);
ucs.toUTF8String(grouping);
ucs.remove();
return resultInJson(pattern, cc, fraction, rounding, decimal, grouping);
}
void
IntlTestNumberFormat::testFormat(/* char* par */)
{
if (U_FAILURE(fStatus))
{
dataerrln((UnicodeString)"**** FAIL: createXxxInstance failed. - " + u_errorName(fStatus));
if (fFormat != 0)
errln("**** FAIL: Non-null format returned by createXxxInstance upon failure.");
delete fFormat;
fFormat = 0;
return;
}
if (fFormat == 0)
{
errln((UnicodeString)"**** FAIL: Null format returned by createXxxInstance.");
return;
}
UnicodeString str;
// Assume it's a DecimalFormat and get some info
DecimalFormat *s = (DecimalFormat*)fFormat;
logln((UnicodeString)" Pattern " + s->toPattern(str));
#if defined(OS390) || defined(OS400)
tryIt(-2.02147304840132e-68);
tryIt(3.88057859588817e-68); // Test rounding when only some digits are shown because exponent is close to -maxfrac
tryIt(-2.64651110485945e+65); // Overflows to +INF when shown as a percent
tryIt(9.29526819488338e+64); // Ok -- used to fail?
#else
tryIt(-2.02147304840132e-100);
tryIt(3.88057859588817e-096); // Test rounding when only some digits are shown because exponent is close to -maxfrac
tryIt(-2.64651110485945e+306); // Overflows to +INF when shown as a percent
tryIt(9.29526819488338e+250); // Ok -- used to fail?
#endif
// These PASS now, with the sprintf/atof based format-parse.
// These fail due to round-off
// The least significant digit drops by one during each format-parse cycle.
// Both numbers DON'T have a round-off problem when multiplied by 100! (shown as %)
#ifdef OS390
tryIt(-9.18228054496402e+64);
tryIt(-9.69413034454191e+64);
#else
tryIt(-9.18228054496402e+255);
tryIt(-9.69413034454191e+273);
#endif
#ifndef OS390
tryIt(1.234e-200);
tryIt(-2.3e-168);
tryIt(uprv_getNaN());
tryIt(uprv_getInfinity());
tryIt(-uprv_getInfinity());
#endif
tryIt((int32_t)251887531);
tryIt(5e-20 / 9);
tryIt(5e20 / 9);
tryIt(1.234e-50);
tryIt(9.99999999999996);
tryIt(9.999999999999996);
tryIt((int32_t)INT32_MIN);
tryIt((int32_t)INT32_MAX);
tryIt((double)INT32_MIN);
tryIt((double)INT32_MAX);
tryIt((double)INT32_MIN - 1.0);
tryIt((double)INT32_MAX + 1.0);
tryIt(5.0 / 9.0 * 1e-20);
tryIt(4.0 / 9.0 * 1e-20);
tryIt(5.0 / 9.0 * 1e+20);
tryIt(4.0 / 9.0 * 1e+20);
tryIt(2147483647.);
tryIt((int32_t)0);
tryIt(0.0);
tryIt((int32_t)1);
tryIt((int32_t)10);
tryIt((int32_t)100);
tryIt((int32_t)-1);
tryIt((int32_t)-10);
tryIt((int32_t)-100);
tryIt((int32_t)-1913860352);
for (int32_t z=0; z<10; ++z)
{
double d = randFraction() * 2e10 - 1e10;
tryIt(d);
}
double it = getSafeDouble(100000.0);
tryIt(0.0);
tryIt(it);
tryIt((int32_t)0);
tryIt(uprv_floor(it));
tryIt((int32_t)randLong());
// try again
it = getSafeDouble(100.0);
tryIt(it);
tryIt(uprv_floor(it));
tryIt((int32_t)randLong());
// try again with very large numbers
it = getSafeDouble(100000000000.0);
tryIt(it);
// try again with very large numbers
// and without going outside of the int32_t range
it = randFraction() * INT32_MAX;
tryIt(it);
tryIt((int32_t)uprv_floor(it));
delete fFormat;
}
