/**
*******************************************************************************
* Copyright (C) 1996-2005, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*
*******************************************************************************
*/
#include "JNIHelp.h"
#include "AndroidSystemNatives.h"
#include "ErrorCode.h"
#include "unicode/ucol.h"
#include "unicode/ucoleitr.h"
#include "ucol_imp.h"
/**
* Closing a C UCollator with the argument locale rules.
* Note determining if a collator currently exist for the caller is to be handled
* by the caller. Hence if the caller has a existing collator, it is his
* responsibility to delete first before calling this method.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address of the C UCollator
*/
static void closeCollator(JNIEnv *env, jclass obj,
jint address) {
UCollator *collator = (UCollator *)(int)address;
ucol_close(collator);
}
/**
* Close a C collation element iterator.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address of C collation element iterator to close.
*/
static void closeElements(JNIEnv *env, jclass obj,
jint address) {
UCollationElements *iterator = (UCollationElements *)(int)address;
ucol_closeElements(iterator);
}
/**
* Compare two strings.
* The strings will be compared using the normalization mode and options
* specified in openCollator or openCollatorFromRules
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address address of the c collator
* @param source The source string.
* @param target The target string.
* @return result of the comparison, UCOL_EQUAL, UCOL_GREATER or UCOL_LESS
*/
static jint compare(JNIEnv *env, jclass obj, jint address,
jstring source, jstring target) {
const UCollator *collator = (const UCollator *)(int)address;
jint result = -2;
if(collator){
jsize srcLength = env->GetStringLength(source);
const UChar *chars = (const UChar *) env->GetStringCritical(source,0);
if(chars){
jsize tgtlength = env->GetStringLength(target);
const UChar *tgtstr = (const UChar *) env->GetStringCritical(target,0);
if(tgtstr){
result = ucol_strcoll(collator, chars, srcLength, tgtstr, tgtlength);
env->ReleaseStringCritical(source, chars);
env->ReleaseStringCritical(target, tgtstr);
return result;
}else{
icu4jni_error(env,U_ILLEGAL_ARGUMENT_ERROR);
}
}else{
icu4jni_error(env,U_ILLEGAL_ARGUMENT_ERROR);
}
}else{
icu4jni_error(env,U_ILLEGAL_ARGUMENT_ERROR);
}
return result;
}
/**
* Universal attribute getter
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address address of the C collator
* @param type type of attribute to be set
* @return attribute value
* @exception thrown when error occurs while getting attribute value
*/
static jint getAttribute(JNIEnv *env, jclass obj, jint address,
jint type) {
const UCollator *collator = (const UCollator *)(int)address;
UErrorCode status = U_ZERO_ERROR;
if(collator){
jint result = (jint)ucol_getAttribute(collator, (UColAttribute)type,
&status);
if (icu4jni_error(env, status) != FALSE){
return (jint)UCOL_DEFAULT;
}
return result;
}else{
icu4jni_error(env,U_ILLEGAL_ARGUMENT_ERROR);
}
return (jint)UCOL_DEFAULT;
}
/**
* Create a CollationElementIterator object that will iterator over the elements
* in a string, using the collation rules defined in this RuleBasedCollatorJNI
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address address of C collator
* @param source string to iterate over
* @return address of C collationelement
*/
static jint getCollationElementIterator(JNIEnv *env,
jclass obj, jint address, jstring source) {
UErrorCode status = U_ZERO_ERROR;
UCollator *collator = (UCollator *)(int)address;
jint result=0;
if(collator){
jsize srcLength = env->GetStringLength(source);
const UChar *chars = (const UChar *) env->GetStringCritical(source,0);
if(chars){
result = (jint)(ucol_openElements(collator, chars, srcLength, &status));
env->ReleaseStringCritical(source, chars);
icu4jni_error(env, status);
}else{
icu4jni_error(env, U_ILLEGAL_ARGUMENT_ERROR);
}
}else{
icu4jni_error(env, U_ILLEGAL_ARGUMENT_ERROR);
}
return result;
}
/**
* Get the maximum length of any expansion sequences that end with the specified
* comparison order.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address of the C collation element iterator containing the text.
* @param order collation order returned by previous or next.
* @return maximum length of any expansion sequences ending with the specified
* order or 1 if collation order does not occur at the end of any
* expansion sequence.
*/
static jint getMaxExpansion(JNIEnv *env, jclass obj,
jint address, jint order) {
UCollationElements *iterator = (UCollationElements *)(int)address;
return ucol_getMaxExpansion(iterator, order);
}
/**
* Get the normalization mode for this object.
* The normalization mode influences how strings are compared.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address of C collator
* @return normalization mode; one of the values from NormalizerEnum
*/
static jint getNormalization(JNIEnv *env, jclass obj,
jint address) {
const UCollator* collator = (const UCollator*) address;
UErrorCode status = U_ZERO_ERROR;
jint result = ucol_getAttribute(collator, UCOL_NORMALIZATION_MODE, &status);
icu4jni_error(env, status);
return result;
}
/**
* Set the normalization mode for this object.
* The normalization mode influences how strings are compared.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address of C collator
* @param mode the normalization mode
*/
static void setNormalization(JNIEnv *env, jclass, jint address, jint mode) {
UCollator* collator = reinterpret_cast<UCollator*>(static_cast<uintptr_t>(address));
UErrorCode status = U_ZERO_ERROR;
ucol_setAttribute(collator, UCOL_NORMALIZATION_MODE, UColAttributeValue(mode), &status);
icu4jni_error(env, status);
}
/**
* Get the offset of the current source character.
* This is an offset into the text of the character containing the current
* collation elements.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param addresss of the C collation elements iterator to query.
* @return offset of the current source character.
*/
static jint getOffset(JNIEnv *env, jclass obj, jint address) {
UCollationElements *iterator = (UCollationElements *)(int)address;
return ucol_getOffset(iterator);
}
/**
* Get the collation rules from a UCollator.
* The rules will follow the rule syntax.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address the address of the C collator
* @return collation rules.
*/
static jstring getRules(JNIEnv *env, jclass obj,
jint address) {
const UCollator *collator = (const UCollator *)(int)address;
int32_t length=0;
const UChar *rules = ucol_getRules(collator, &length);
return env->NewString(rules, length);
}
/**
* Get a sort key for the argument string
* Sort keys may be compared using java.util.Arrays.equals
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address address of the C collator
* @param source string for key to be generated
* @return sort key
*/
static jbyteArray getSortKey(JNIEnv *env, jclass obj,
jint address, jstring source) {
const UCollator *collator = (const UCollator *)(int)address;
jbyteArray result = NULL;
if(collator && source){
// BEGIN android-added
if(!source) {
return NULL;
}
// END android-added
jsize srcLength = env->GetStringLength(source);
const UChar *chars = (const UChar *) env->GetStringCritical(source, 0);
if (chars){
// BEGIN android-changed
uint8_t byteArray[UCOL_MAX_BUFFER * 2];
uint8_t *largerByteArray = NULL;
uint8_t *usedByteArray = byteArray;
size_t byteArraySize = ucol_getSortKey(collator, chars, srcLength, byteArray,
sizeof(byteArray) - 1);
if (byteArraySize > sizeof(byteArray) - 1) {
// didn't fit, try again with a larger buffer.
largerByteArray = new uint8_t[byteArraySize + 1];
usedByteArray = largerByteArray;
byteArraySize = ucol_getSortKey(collator, chars, srcLength, largerByteArray,
byteArraySize);
}
env->ReleaseStringCritical(source, chars);
if (byteArraySize == 0) {
delete[] largerByteArray;
return NULL;
}
/* no problem converting uint8_t to int8_t, gives back the correct value
* tried and tested
*/
result = env->NewByteArray(byteArraySize);
env->SetByteArrayRegion(result, 0, byteArraySize, reinterpret_cast<jbyte*>(usedByteArray));
delete[] largerByteArray;
// END android-changed
}else{
icu4jni_error(env,U_ILLEGAL_ARGUMENT_ERROR);
}
}else{
icu4jni_error(env,U_ILLEGAL_ARGUMENT_ERROR);
}
return result;
}
/**
* Returns a hash of this collation object
* Note this method is not complete, it only returns 0 at the moment.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address address of C collator
* @return hash of this collation object
*/
static jint hashCode(JNIEnv *env, jclass obj, jint address) {
UCollator *collator = (UCollator *)(int)address;
int32_t length=0;
const UChar *rules = ucol_getRules(collator, &length);
/* temporary commented out
* return uhash_hashUCharsN(rules, length);
*/
return 0;
}
/**
* Get the ordering priority of the next collation element in the text.
* A single character may contain more than one collation element.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address if C collation elements containing the text.
* @return next collation elements ordering, otherwise returns NULLORDER if an
* error has occured or if the end of string has been reached
*/
static jint next(JNIEnv *env, jclass obj, jint address) {
UCollationElements *iterator = (UCollationElements *) address;
UErrorCode status = U_ZERO_ERROR;
jint result = ucol_next(iterator, &status);
icu4jni_error(env, status);
return result;
}
/**
* Opening a new C UCollator with the default locale.
* Note determining if a collator currently exist for the caller is to be handled
* by the caller. Hence if the caller has a existing collator, it is his
* responsibility to delete first before calling this method.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @return address of the new C UCollator
* @exception thrown if creation of the UCollator fails
*/
static jint openCollator__(JNIEnv *env, jclass obj) {
UErrorCode status = U_ZERO_ERROR;
UCollator* result = ucol_open(NULL, &status);
icu4jni_error(env, status);
return reinterpret_cast<uintptr_t>(result);
}
/**
* Opening a new C UCollator with the argument locale rules.
* Note determining if a collator currently exist for the caller is to be handled
* by the caller. Hence if the caller has a existing collator, it is his
* responsibility to delete first before calling this method.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param locale name
* @return address of the new C UCollator
* @exception thrown if creation of the UCollator fails
*/
static jint openCollator__Ljava_lang_String_2(JNIEnv *env,
jclass obj, jstring locale) {
/* this will be null terminated */
const char* localeStr = env->GetStringUTFChars(locale, NULL);
if (localeStr == NULL) {
icu4jni_error(env, U_ILLEGAL_ARGUMENT_ERROR);
return 0;
}
UErrorCode status = U_ZERO_ERROR;
UCollator* result = ucol_open(localeStr, &status);
env->ReleaseStringUTFChars(locale, localeStr);
icu4jni_error(env, status);
return reinterpret_cast<uintptr_t>(result);
}
/**
* Opening a new C UCollator with the argument locale rules.
* Note determining if a collator currently exist for the caller is to be
* handled by the caller. Hence if the caller has a existing collator, it is his
* responsibility to delete first before calling this method.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param rules set of collation rules
* @param normalizationmode normalization mode
* @param strength collation strength
* @return address of the new C UCollator
* @exception thrown if creation of the UCollator fails
*/
static jint openCollatorFromRules(JNIEnv *env, jclass obj,
jstring rules, jint normalizationmode, jint strength) {
jsize ruleslength = env->GetStringLength(rules);
const UChar *rulestr = (const UChar *) env->GetStringCritical(rules, 0);
UErrorCode status = U_ZERO_ERROR;
jint result = 0;
if(rulestr){
result = (jint)ucol_openRules(rulestr, ruleslength,
(UColAttributeValue)normalizationmode,
(UCollationStrength)strength, NULL, &status);
env->ReleaseStringCritical(rules, rulestr);
icu4jni_error(env, status);
}else{
icu4jni_error(env,U_ILLEGAL_ARGUMENT_ERROR);
}
return result;
}
/**
* Get the ordering priority of the previous collation element in the text.
* A single character may contain more than one collation element.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address of the C collation element iterator containing the text.
* @return previous collation element ordering, otherwise returns NULLORDER if
* an error has occured or if the start of string has been reached
* @exception thrown when retrieval of previous collation element fails.
*/
static jint previous(JNIEnv *env, jclass obj, jint address) {
UCollationElements *iterator = (UCollationElements *)(int)address;
UErrorCode status = U_ZERO_ERROR;
jint result = ucol_previous(iterator, &status);
icu4jni_error(env, status);
return result;
}
/**
* Reset the collation elements to their initial state.
* This will move the 'cursor' to the beginning of the text.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address of C collation element iterator to reset.
*/
static void reset(JNIEnv *env, jclass obj, jint address) {
UCollationElements *iterator = (UCollationElements *)(int)address;
ucol_reset(iterator);
}
/**
* Thread safe cloning operation
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address address of C collator to be cloned
* @return address of the new clone
* @exception thrown when error occurs while cloning
*/
static jint safeClone(JNIEnv *env, jclass obj, jint address) {
const UCollator *collator = (const UCollator *)(int)address;
UErrorCode status = U_ZERO_ERROR;
jint result;
jint buffersize = U_COL_SAFECLONE_BUFFERSIZE;
result = (jint)ucol_safeClone(collator, NULL, &buffersize, &status);
if ( icu4jni_error(env, status) != FALSE) {
return 0;
}
return result;
}
/**
* Universal attribute setter.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address address of the C collator
* @param type type of attribute to be set
* @param value attribute value
* @exception thrown when error occurs while setting attribute value
*/
static void setAttribute(JNIEnv *env, jclass obj, jint address,
jint type, jint value) {
UCollator *collator = (UCollator *)(int)address;
UErrorCode status = U_ZERO_ERROR;
ucol_setAttribute(collator, (UColAttribute)type, (UColAttributeValue)value,
&status);
icu4jni_error(env, status);
}
/**
* Set the offset of the current source character.
* This is an offset into the text of the character to be processed.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address of the C collation element iterator to set.
* @param offset The desired character offset.
* @exception thrown when offset setting fails
*/
static void setOffset(JNIEnv *env, jclass obj, jint address,
jint offset) {
UCollationElements *iterator = (UCollationElements *)(int)address;
UErrorCode status = U_ZERO_ERROR;
ucol_setOffset(iterator, offset, &status);
icu4jni_error(env, status);
}
/**
* Set the text containing the collation elements.
* @param env JNI environment
* @param obj RuleBasedCollatorJNI object
* @param address of the C collation element iterator to be set
* @param source text containing the collation elements.
* @exception thrown when error occurs while setting offset
*/
static void setText(JNIEnv *env, jclass obj, jint address,
jstring source) {
UCollationElements *iterator = (UCollationElements *)(int)address;
UErrorCode status = U_ZERO_ERROR;
int strlength = env->GetStringLength(source);
const UChar *str = (const UChar *) env->GetStringCritical(source, 0);
ucol_setText(iterator, str, strlength, &status);
env->ReleaseStringCritical(source, str);
icu4jni_error(env, status);
}
static jobjectArray getAvailableLocalesImpl(JNIEnv *env, jclass clazz) {
jclass stringClass = env->FindClass("java/lang/String");
if (stringClass == NULL) {
return NULL;
}
size_t count = ucol_countAvailable();
jobjectArray result = env->NewObjectArray(count, stringClass, NULL);
for (size_t i = 0; i < count; ++i) {
jstring s = env->NewStringUTF(ucol_getAvailable(i));
env->SetObjectArrayElement(result, i, s);
env->DeleteLocalRef(s);
}
return result;
}
static JNINativeMethod gMethods[] = {
/* name, signature, funcPtr */
{ "getAvailableLocalesImpl", "()[Ljava/lang/String;", (void*) getAvailableLocalesImpl },
{ "openCollator", "()I", (void*) openCollator__ },
{ "openCollator", "(Ljava/lang/String;)I", (void*) openCollator__Ljava_lang_String_2 },
{ "openCollatorFromRules", "(Ljava/lang/String;II)I", (void*) openCollatorFromRules },
{ "closeCollator", "(I)V", (void*) closeCollator },
{ "compare", "(ILjava/lang/String;Ljava/lang/String;)I", (void*) compare },
{ "getNormalization", "(I)I", (void*) getNormalization },
{ "setNormalization", "(II)V", (void*) setNormalization },
{ "getRules", "(I)Ljava/lang/String;", (void*) getRules },
{ "getSortKey", "(ILjava/lang/String;)[B", (void*) getSortKey },
{ "setAttribute", "(III)V", (void*) setAttribute },
{ "getAttribute", "(II)I", (void*) getAttribute },
{ "safeClone", "(I)I", (void*) safeClone },
{ "getCollationElementIterator", "(ILjava/lang/String;)I", (void*) getCollationElementIterator },
{ "hashCode", "(I)I", (void*) hashCode },
{ "closeElements", "(I)V", (void*) closeElements },
{ "reset", "(I)V", (void*) reset },
{ "next", "(I)I", (void*) next },
{ "previous", "(I)I", (void*) previous },
{ "getMaxExpansion", "(II)I", (void*) getMaxExpansion },
{ "setText", "(ILjava/lang/String;)V", (void*) setText },
{ "getOffset", "(I)I", (void*) getOffset },
{ "setOffset", "(II)V", (void*) setOffset }
};
int register_com_ibm_icu4jni_text_NativeCollator(JNIEnv *_env) {
return jniRegisterNativeMethods(_env, "com/ibm/icu4jni/text/NativeCollation",
gMethods, NELEM(gMethods));
}