//static void NativeDecimalFormat_setRoundingMode(JNIEnv*, jclass, jint addr, jint mode, jdouble increment) {
JNIEXPORT void JNICALL
Java_com_ibm_icu4jni_text_NativeDecimalFormat_setRoundingMode(JNIEnv*, jclass,
jint addr, jint mode, jdouble increment) {
DecimalFormat* fmt = toDecimalFormat(addr);
fmt->setRoundingMode(static_cast<DecimalFormat::ERoundingMode> (mode));
fmt->setRoundingIncrement(increment);
}
static jcharArray format(JNIEnv* env, jint addr, jobject fpIter, T val) {
UErrorCode status = U_ZERO_ERROR;
UnicodeString str;
DecimalFormat* fmt = toDecimalFormat(addr);
FieldPositionIterator fpi;
FieldPositionIterator* pfpi = fpIter ? &fpi : NULL;
fmt->format(reinterpret_cast<const Formattable&>(val), str, pfpi, status);
return formatResult(env, str, pfpi, fpIter);
}
static jobject NativeDecimalFormat_parse(JNIEnv* env, jclass, jlong addr, jstring text,
jobject position, jboolean parseBigDecimal) {
static jmethodID gPP_getIndex = env->GetMethodID(JniConstants::parsePositionClass, "getIndex", "()I");
static jmethodID gPP_setIndex = env->GetMethodID(JniConstants::parsePositionClass, "setIndex", "(I)V");
static jmethodID gPP_setErrorIndex = env->GetMethodID(JniConstants::parsePositionClass, "setErrorIndex", "(I)V");
ScopedJavaUnicodeString src(env, text);
if (!src.valid()) {
return NULL;
}
// make sure the ParsePosition is valid. Actually icu4c would parse a number
// correctly even if the parsePosition is set to -1, but since the RI fails
// for that case we have to fail too
int parsePos = env->CallIntMethod(position, gPP_getIndex, NULL);
if (parsePos < 0 || parsePos > env->GetStringLength(text)) {
return NULL;
}
Formattable res;
ParsePosition pp(parsePos);
DecimalFormat* fmt = toDecimalFormat(addr);
fmt->parse(src.unicodeString(), res, pp);
if (pp.getErrorIndex() == -1) {
env->CallVoidMethod(position, gPP_setIndex, pp.getIndex());
} else {
env->CallVoidMethod(position, gPP_setErrorIndex, pp.getErrorIndex());
return NULL;
}
if (parseBigDecimal) {
UErrorCode status = U_ZERO_ERROR;
StringPiece str = res.getDecimalNumber(status);
if (U_SUCCESS(status)) {
int len = str.length();
const char* data = str.data();
if (strncmp(data, "NaN", 3) == 0 ||
strncmp(data, "Inf", 3) == 0 ||
strncmp(data, "-Inf", 4) == 0) {
double resultDouble = res.getDouble(status);
return doubleValueOf(env, resultDouble);
}
return newBigDecimal(env, data, len);
}
return NULL;
}
switch (res.getType()) {
case Formattable::kDouble: return doubleValueOf(env, res.getDouble());
case Formattable::kLong: return longValueOf(env, res.getLong());
case Formattable::kInt64: return longValueOf(env, res.getInt64());
default: return NULL;
}
}
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 jcharArray format(JNIEnv* env, jlong addr, jobject javaFieldPositionIterator, T value) {
UErrorCode status = U_ZERO_ERROR;
UnicodeString s;
DecimalFormat* fmt = toDecimalFormat(addr);
FieldPositionIterator nativeFieldPositionIterator;
FieldPositionIterator* fpi = javaFieldPositionIterator ? &nativeFieldPositionIterator : NULL;
fmt->format(value, s, fpi, status);
if (maybeThrowIcuException(env, "DecimalFormat::format", status)) {
return NULL;
}
return formatResult(env, s, fpi, javaFieldPositionIterator);
}
//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());
}
static void NativeDecimalFormat_setDecimalFormatSymbols(JNIEnv* env, jclass, jlong addr,
jstring currencySymbol, jchar decimalSeparator, jchar digit, jstring exponentSeparator,
jchar groupingSeparator, jstring infinity,
jstring internationalCurrencySymbol, jstring minusSign,
jchar monetaryDecimalSeparator, jstring nan, jchar patternSeparator,
jstring percent, jchar perMill, jchar zeroDigit) {
DecimalFormatSymbols* symbols = makeDecimalFormatSymbols(env,
currencySymbol, decimalSeparator, digit, exponentSeparator, groupingSeparator,
infinity, internationalCurrencySymbol, minusSign,
monetaryDecimalSeparator, nan, patternSeparator, percent, perMill,
zeroDigit);
toDecimalFormat(addr)->adoptDecimalFormatSymbols(symbols);
}
static void NativeDecimalFormat_applyPatternImpl(JNIEnv* env, jclass, jlong addr, jboolean localized, jstring pattern0) {
ScopedJavaUnicodeString pattern(env, pattern0);
if (!pattern.valid()) {
return;
}
DecimalFormat* fmt = toDecimalFormat(addr);
UErrorCode status = U_ZERO_ERROR;
const char* function;
if (localized) {
function = "DecimalFormat::applyLocalizedPattern";
fmt->applyLocalizedPattern(pattern.unicodeString(), status);
} else {
function = "DecimalFormat::applyPattern";
fmt->applyPattern(pattern.unicodeString(), status);
}
maybeThrowIcuException(env, function, status);
}
//static void NativeDecimalFormat_applyPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized, jstring pattern0) {
JNIEXPORT void JNICALL
Java_com_ibm_icu4jni_text_NativeDecimalFormat_applyPatternImpl(JNIEnv* env,
jclass, jint addr, jboolean localized, jstring pattern0) {
if (pattern0 == NULL) {
jniThrowNullPointerException(env, NULL);
return;
}
ScopedJavaUnicodeString pattern(env, pattern0);
DecimalFormat* fmt = toDecimalFormat(addr);
UErrorCode status = U_ZERO_ERROR;
if (localized) {
fmt->applyLocalizedPattern(pattern.unicodeString(), status);
} else {
fmt->applyPattern(pattern.unicodeString(), status);
}
icu4jni_error(env, status);
}
static jlong NativeDecimalFormat_cloneImpl(JNIEnv*, jclass, jlong addr) {
DecimalFormat* fmt = toDecimalFormat(addr);
return reinterpret_cast<uintptr_t>(fmt->clone());
}
static void NativeDecimalFormat_setRoundingMode(JNIEnv*, jclass, jlong addr, jint mode, jdouble increment) {
DecimalFormat* fmt = toDecimalFormat(addr);
fmt->setRoundingMode(static_cast<DecimalFormat::ERoundingMode>(mode));
fmt->setRoundingIncrement(increment);
}
static void NativeDecimalFormat_close(JNIEnv*, jclass, jlong addr) {
delete toDecimalFormat(addr);
}
//static jint NativeDecimalFormat_cloneImpl(JNIEnv*, jclass, jint addr) {
JNIEXPORT jint JNICALL
Java_com_ibm_icu4jni_text_NativeDecimalFormat_cloneImpl(JNIEnv*, jclass,
jint addr) {
DecimalFormat* fmt = toDecimalFormat(addr);
return static_cast<jint> (reinterpret_cast<uintptr_t> (fmt->clone()));
}
//static void NativeDecimalFormat_close(JNIEnv*, jclass, jint addr) {
JNIEXPORT void JNICALL
Java_com_ibm_icu4jni_text_NativeDecimalFormat_close(JNIEnv*, jclass, jint addr) {
delete toDecimalFormat(addr);
}
