Collator::Collator(const char* locale, bool shouldSortLowercaseFirst) { UErrorCode status = U_ZERO_ERROR; { std::lock_guard<Lock> lock(cachedCollatorMutex); if (cachedCollator && localesMatch(cachedCollatorLocale, locale) && cachedCollatorShouldSortLowercaseFirst == shouldSortLowercaseFirst) { m_collator = cachedCollator; m_locale = cachedCollatorLocale; m_shouldSortLowercaseFirst = shouldSortLowercaseFirst; cachedCollator = nullptr; cachedCollatorLocale = nullptr; return; } } m_collator = ucol_open(resolveDefaultLocale(locale), &status); if (U_FAILURE(status)) { status = U_ZERO_ERROR; m_collator = ucol_open("", &status); // Fall back to Unicode Collation Algorithm. } ASSERT(U_SUCCESS(status)); ucol_setAttribute(m_collator, UCOL_CASE_FIRST, shouldSortLowercaseFirst ? UCOL_LOWER_FIRST : UCOL_UPPER_FIRST, &status); ASSERT(U_SUCCESS(status)); ucol_setAttribute(m_collator, UCOL_NORMALIZATION_MODE, UCOL_ON, &status); ASSERT(U_SUCCESS(status)); m_locale = locale ? fastStrDup(locale) : nullptr; m_shouldSortLowercaseFirst = shouldSortLowercaseFirst; }
static void TestFCDCrash(void) { static const char *test[] = { "Gr\\u00F6\\u00DFe", "Grossist" }; char *icuDataDir = safeGetICUDataDirectory(); UErrorCode status = U_ZERO_ERROR; UCollator *coll = ucol_open("es", &status); if(U_FAILURE(status)) { log_err("Couldn't open collator\n"); return; } ucol_close(coll); coll = NULL; u_cleanup(); u_setDataDirectory(icuDataDir); coll = ucol_open("de_DE", &status); if(U_FAILURE(status)) { log_err("Couldn't open collator\n"); return; } ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status); genericOrderingTest(coll, test, 2); ucol_close(coll); free(icuDataDir); }
static ErlDrvData couch_drv_start(ErlDrvPort port, char *buff) { UErrorCode status = U_ZERO_ERROR; couch_drv_data* pData = (couch_drv_data*)driver_alloc(sizeof(couch_drv_data)); if (pData == NULL) return ERL_DRV_ERROR_GENERAL; pData->port = port; pData->coll = ucol_open("", &status); if (U_FAILURE(status)) { couch_drv_stop((ErlDrvData)pData); return ERL_DRV_ERROR_GENERAL; } pData->collNoCase = ucol_open("", &status); if (U_FAILURE(status)) { couch_drv_stop((ErlDrvData)pData); return ERL_DRV_ERROR_GENERAL; } ucol_setAttribute(pData->collNoCase, UCOL_STRENGTH, UCOL_PRIMARY, &status); if (U_FAILURE(status)) { couch_drv_stop((ErlDrvData)pData); return ERL_DRV_ERROR_GENERAL; } return (ErlDrvData)pData; }
void Collator::createCollator() const { ASSERT(!m_collator); UErrorCode status = U_ZERO_ERROR; { Locker<Mutex> lock(cachedCollatorMutex()); if (cachedCollator) { UColAttributeValue cachedCollatorLowerFirst = ucol_getAttribute(cachedCollator, UCOL_CASE_FIRST, &status); ASSERT(U_SUCCESS(status)); if (0 == strcmp(cachedEquivalentLocale, m_equivalentLocale) && ((UCOL_LOWER_FIRST == cachedCollatorLowerFirst && m_lowerFirst) || (UCOL_UPPER_FIRST == cachedCollatorLowerFirst && !m_lowerFirst))) { m_collator = cachedCollator; cachedCollator = 0; cachedEquivalentLocale[0] = 0; return; } } } m_collator = ucol_open(m_locale, &status); if (U_FAILURE(status)) { status = U_ZERO_ERROR; m_collator = ucol_open("", &status); // Fallback to Unicode Collation Algorithm. } ASSERT(U_SUCCESS(status)); ucol_setAttribute(m_collator, UCOL_CASE_FIRST, m_lowerFirst ? UCOL_LOWER_FIRST : UCOL_UPPER_FIRST, &status); ASSERT(U_SUCCESS(status)); ucol_setAttribute(m_collator, UCOL_NORMALIZATION_MODE, UCOL_ON, &status); ASSERT(U_SUCCESS(status)); }
static void TestFCDCrash(void) { static const char *test[] = { "Gr\\u00F6\\u00DFe", "Grossist" }; UErrorCode status = U_ZERO_ERROR; UCollator *coll = ucol_open("es", &status); if(U_FAILURE(status)) { log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status)); return; } ucol_close(coll); coll = NULL; ctest_resetICU(); coll = ucol_open("de_DE", &status); if(U_FAILURE(status)) { log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status)); return; } ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status); genericOrderingTest(coll, test, 2); ucol_close(coll); }
void Collator::createCollator() const { ASSERT(!m_collator); UErrorCode status = U_ZERO_ERROR; { Locker<Mutex> lock(cachedCollatorMutex()); if (cachedCollator) { const char* cachedCollatorLocale = ucol_getLocaleByType(cachedCollator, ULOC_REQUESTED_LOCALE, &status); ASSERT(U_SUCCESS(status)); ASSERT(cachedCollatorLocale); UColAttributeValue cachedCollatorLowerFirst = ucol_getAttribute(cachedCollator, UCOL_CASE_FIRST, &status); ASSERT(U_SUCCESS(status)); // FIXME: default locale is never matched, because ucol_getLocaleByType returns the actual one used, not 0. if (m_locale && 0 == strcmp(cachedCollatorLocale, m_locale) && ((UCOL_LOWER_FIRST == cachedCollatorLowerFirst && m_lowerFirst) || (UCOL_UPPER_FIRST == cachedCollatorLowerFirst && !m_lowerFirst))) { m_collator = cachedCollator; cachedCollator = 0; return; } } } m_collator = ucol_open(m_locale, &status); if (U_FAILURE(status)) { status = U_ZERO_ERROR; m_collator = ucol_open("", &status); // Fallback to Unicode Collation Algorithm. } ASSERT(U_SUCCESS(status)); ucol_setAttribute(m_collator, UCOL_CASE_FIRST, m_lowerFirst ? UCOL_LOWER_FIRST : UCOL_UPPER_FIRST, &status); ASSERT(U_SUCCESS(status)); }
int helper_collation_str(const char *src, char *dest, int dest_size) { HELPER_FN_CALL; int32_t size = 0; UErrorCode status = 0; UChar tmp_result[CTS_SQL_MAX_LEN]; UCollator *collator; const char *region; region = vconf_get_str(VCONFKEY_REGIONFORMAT); HELPER_DBG("region %s", region); collator = ucol_open(region, &status); h_retvm_if(U_FAILURE(status), CTS_ERR_ICU_FAILED, "ucol_open() Failed(%s)", u_errorName(status)); if (U_FAILURE(status)){ ERR("ucol_setAttribute Failed(%s)", u_errorName(status)); ucol_close(collator); return CTS_ERR_ICU_FAILED; } u_strFromUTF8(tmp_result, array_sizeof(tmp_result), NULL, src, -1, &status); if (U_FAILURE(status)){ ERR("u_strFromUTF8 Failed(%s)", u_errorName(status)); ucol_close(collator); return CTS_ERR_ICU_FAILED; } size = ucol_getSortKey(collator, tmp_result, -1, (uint8_t *)dest, dest_size); ucol_close(collator); dest[size]='\0'; return CTS_SUCCESS; }
static void TestSecondary() { int32_t i,j, testAcuteSize; UCollationResult expected=UCOL_EQUAL; UErrorCode status = U_ZERO_ERROR; myCollation = ucol_open("fr_CA", &status); if(U_FAILURE(status)) { log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status)); return; } ucol_setAttribute(myCollation, UCOL_STRENGTH, UCOL_SECONDARY, &status); if(U_FAILURE(status)) { log_err("ERROR: in creation of rule based collator: %s\n", myErrorName(status)); return; } log_verbose("Testing fr_CA Collation with Secondary strength\n"); /*test acute and grave ordering (compare to french collation)*/ testAcuteSize = UPRV_LENGTHOF(testAcute); for (i = 0; i < testAcuteSize; i++) { for (j = 0; j < testAcuteSize; j++) { if (i < j) expected = UCOL_LESS; if (i == j) expected = UCOL_EQUAL; if (i > j) expected = UCOL_GREATER; doTest(myCollation, testAcute[i], testAcute[j], expected ); } } ucol_close(myCollation); }
MojErr MojDbTextCollator::init(const MojChar* locale, MojDbCollationStrength level) { MojAssert(locale); MojAssert(!m_ucol); UCollationStrength strength = UCOL_PRIMARY; switch (level) { case MojDbCollationPrimary: strength = UCOL_PRIMARY; break; case MojDbCollationSecondary: strength = UCOL_SECONDARY; break; case MojDbCollationTertiary: strength = UCOL_TERTIARY; break; case MojDbCollationIdentical: strength = UCOL_IDENTICAL; break; default: MojAssertNotReached(); } UErrorCode status = U_ZERO_ERROR; m_ucol = ucol_open(locale, &status); MojUnicodeErrCheck(status); MojAssert(m_ucol); ucol_setAttribute(m_ucol, UCOL_NORMALIZATION_MODE, UCOL_ON, &status); MojUnicodeErrCheck(status); ucol_setStrength(m_ucol, strength); return MojErrNone; }
/* Get a collator */ ERL_NIF_TERM get_collator(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM out; char locale[LOCALE_LEN]; UErrorCode status = U_ZERO_ERROR; UCollator* col; cloner* res; unsigned int index; if ((argc != 2) && (argc != 1)) return enif_make_badarg(env); if (!enif_get_atom(env, argv[0], (char*) locale, LOCALE_LEN, ERL_NIF_LATIN1)) { return enif_make_badarg(env); } col = ucol_open((char *) locale, &status); CHECK(env, status); res = (cloner*) enif_alloc_resource(collator_type, sizeof(cloner)); if (collator_open(col, res)) { enif_release_resource(res); return enif_make_badarg(env); } CHECK_DEST(env, status, enif_release_resource(res); );
/* {{{ */ static int collator_ctor(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_constructor) { const char* locale; size_t locale_len = 0; zval* object; Collator_object* co; int zpp_flags = is_constructor ? ZEND_PARSE_PARAMS_THROW : 0; intl_error_reset( NULL ); object = return_value; /* Parse parameters. */ if( zend_parse_parameters_ex( zpp_flags, ZEND_NUM_ARGS(), "s", &locale, &locale_len ) == FAILURE ) { intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "collator_create: unable to parse input params", 0 ); return FAILURE; } INTL_CHECK_LOCALE_LEN_OR_FAILURE(locale_len); COLLATOR_METHOD_FETCH_OBJECT; if(locale_len == 0) { locale = intl_locale_get_default(); } /* Open ICU collator. */ co->ucoll = ucol_open( locale, COLLATOR_ERROR_CODE_P( co ) ); INTL_CTOR_CHECK_STATUS(co, "collator_create: unable to open ICU collator"); return SUCCESS; }
CF_INLINE UCollator * CFStringICUCollatorOpen (CFStringCompareFlags options, CFLocaleRef loc) { const char *cLocale; char buffer[ULOC_FULLNAME_CAPACITY]; UCollator *ret; UErrorCode err = U_ZERO_ERROR; if (loc != NULL && (options & kCFCompareLocalized)) cLocale = CFLocaleGetCStringIdentifier (loc, buffer, ULOC_FULLNAME_CAPACITY); else cLocale = NULL; ret = ucol_open (cLocale, &err); if (options) { if (options & kCFCompareCaseInsensitive) ucol_setAttribute (ret, UCOL_CASE_LEVEL, UCOL_OFF, &err); if (options & kCFCompareNonliteral) ucol_setAttribute (ret, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &err); if (options & kCFCompareNumerically) ucol_setAttribute (ret, UCOL_NUMERIC_COLLATION, UCOL_ON, &err); if (options & kCFCompareDiacriticInsensitive) ucol_setAttribute (ret, UCOL_NORMALIZATION_MODE, UCOL_ON, &err); /* FIXME if (compareOptions & kCFCompareWidthInsensitive) */ if (options & kCFCompareForcedOrdering) ucol_setAttribute (ret, UCOL_STRENGTH, UCOL_IDENTICAL, &err); } return ret; }
void SSearchTest::goodSuffixTest() { UErrorCode status = U_ZERO_ERROR; UCollator *coll = NULL; UnicodeString pat = /*"gcagagag"*/ "fxeld"; UnicodeString target = /*"gcatcgcagagagtatacagtacg"*/ "cloveldfxeld"; int32_t start = -1, end = -1; UBool bFound; coll = ucol_open(NULL, &status); TEST_ASSERT_SUCCESS(status); LocalUStringSearchPointer ss(usearch_openFromCollator(pat.getBuffer(), pat.length(), target.getBuffer(), target.length(), coll, NULL, // the break iterator &status)); TEST_ASSERT_SUCCESS(status); bFound = usearch_search(ss.getAlias(), 0, &start, &end, &status); TEST_ASSERT_SUCCESS(status); if (bFound) { logln("Found pattern at [%d, %d].", start, end); } else { dataerrln("Did not find pattern."); } ucol_close(coll); }
/** * Test for CollationElementIterator previous and next for the whole set of * unicode characters with normalization on. */ static void TestNormalizedUnicodeChar() { UChar source[0x100]; UCollator *th_th; UCollationElements *iter; UErrorCode status = U_ZERO_ERROR; UChar codepoint; UChar *test; /* thai should have normalization on */ th_th = ucol_open("th_TH", &status); if (U_FAILURE(status)){ log_err_status(status, "ERROR: in creation of thai collation using ucol_open()\n %s\n", myErrorName(status)); return; } for (codepoint = 1; codepoint < 0xFFFE;) { test = source; while (codepoint % 0xFF != 0) { if (u_isdefined(codepoint)) *(test ++) = codepoint; codepoint ++; } if (u_isdefined(codepoint)) *(test ++) = codepoint; if (codepoint != 0xFFFF) codepoint ++; *test = 0; iter=ucol_openElements(th_th, source, u_strlen(source), &status); if(U_FAILURE(status)){ log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n", myErrorName(status)); ucol_close(th_th); return; } backAndForth(iter); ucol_closeElements(iter); iter=ucol_openElements(th_th, source, -1, &status); if(U_FAILURE(status)){ log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n", myErrorName(status)); ucol_close(th_th); return; } backAndForth(iter); ucol_closeElements(iter); } ucol_close(th_th); }
/* {{{ */ static void collator_ctor(INTERNAL_FUNCTION_PARAMETERS) { const char* locale; size_t locale_len = 0; zval* object; Collator_object* co; intl_error_reset( NULL ); object = return_value; /* Parse parameters. */ if( zend_parse_parameters( ZEND_NUM_ARGS(), "s", &locale, &locale_len ) == FAILURE ) { intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "collator_create: unable to parse input params", 0 ); zval_dtor(return_value); RETURN_NULL(); } INTL_CHECK_LOCALE_LEN_OBJ(locale_len, return_value); COLLATOR_METHOD_FETCH_OBJECT; if(locale_len == 0) { locale = intl_locale_get_default(); } /* Open ICU collator. */ co->ucoll = ucol_open( locale, COLLATOR_ERROR_CODE_P( co ) ); INTL_CTOR_CHECK_STATUS(co, "collator_create: unable to open ICU collator"); }
UCAConformanceTest::UCAConformanceTest() : rbUCA(NULL), testFile(NULL), status(U_ZERO_ERROR) { UCA = ucol_open("root", &status); if(U_FAILURE(status)) { errln("ERROR - UCAConformanceTest: Unable to open UCA collator!"); } uprv_strcpy(testDataPath, IntlTest::loadTestData(status)); if (U_FAILURE(status)) { errln("ERROR: could not open test data %s", u_errorName(status)); return; } char* index = 0; index=strrchr(testDataPath,(char)U_FILE_SEP_CHAR); if((unsigned int)(index-testDataPath) != (strlen(testDataPath)-1)){ *(index+1)=0; } uprv_strcat(testDataPath,".."U_FILE_SEP_STRING); uprv_strcat(testDataPath, "CollationTest_"); }
static void TestSecondary() { UCollationResult expected=UCOL_EQUAL; int32_t i,j, testAcuteSize; UErrorCode status = U_ZERO_ERROR; myCollation = ucol_open("en_US", &status); if(U_FAILURE(status)){ log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status)); return; } ucol_setStrength(myCollation, UCOL_SECONDARY); log_verbose("Testing English Collation with Secondary strength\n"); for (i = 43; i < 49 ; i++) { doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]); } /*test acute and grave ordering (compare to french collation) */ testAcuteSize = UPRV_LENGTHOF(testAcute); for (i = 0; i < testAcuteSize; i++) { for (j = 0; j < testAcuteSize; j++) { if (i < j) expected = UCOL_LESS; if (i == j) expected = UCOL_EQUAL; if (i > j) expected = UCOL_GREATER; doTest(myCollation, testAcute[i], testAcute[j], expected ); } } ucol_close(myCollation); }
/* ** Implementation of the scalar function icu_load_collation(). ** ** This scalar function is used to add ICU collation based collation ** types to an SQLite database connection. It is intended to be called ** as follows: ** ** SELECT icu_load_collation(<locale>, <collation-name>); ** ** Where <locale> is a string containing an ICU locale identifier (i.e. ** "en_AU", "tr_TR" etc.) and <collation-name> is the name of the ** collation sequence to create. */ static void icuLoadCollation( sqlite3_context *p, int nArg, sqlite3_value **apArg ){ sqlite3 *db = (sqlite3 *)sqlite3_user_data(p); UErrorCode status = U_ZERO_ERROR; const char *zLocale; /* Locale identifier - (eg. "jp_JP") */ const char *zName; /* SQL Collation sequence name (eg. "japanese") */ UCollator *pUCollator; /* ICU library collation object */ int rc; /* Return code from sqlite3_create_collation_x() */ assert(nArg==2); zLocale = (const char *)sqlite3_value_text(apArg[0]); zName = (const char *)sqlite3_value_text(apArg[1]); if( !zLocale || !zName ){ return; } pUCollator = ucol_open(zLocale, &status); if( !U_SUCCESS(status) ){ icuFunctionError(p, "ucol_open", status); return; } assert(p); rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator, icuCollationColl, icuCollationDel ); if( rc!=SQLITE_OK ){ ucol_close(pUCollator); sqlite3_result_error(p, "Error registering collation function", -1); } }
static int32_t sortkey_from_unicode (UChar *input, uint8_t **output) { UErrorCode status = U_ZERO_ERROR; UCollator * collator = ucol_open ("", &status); int32_t size; if (icu_failure (status)) return 0; ucol_setAttribute (collator, UCOL_NUMERIC_COLLATION, UCOL_ON, &status); if (icu_failure (status)) return 0; *output = (uint8_t *) palloc (sizeof (uint8_t) * PREALLOC_SIZE); size = ucol_getSortKey (collator, input, -1, *output, PREALLOC_SIZE); if (size > PREALLOC_SIZE) { pfree (*output); *output = (uint8_t *) palloc (sizeof (uint8_t) * size); ucol_getSortKey (collator, input, -1, *output, size); } ucol_close (collator); if (size < 1) { ereport(ERROR, (errmsg("ICU sortkey is zero"))); } return size; }
static int compareUnicodeSlow(const char* str1, size_t len1, const char* str2, size_t len2) { static UCollator* coll = NULL; UCharIterator iterA, iterB; int result; UErrorCode status = U_ZERO_ERROR; if (!coll) { coll = ucol_open("", &status); if (U_FAILURE(status)) { fprintf(stderr, "CouchStore CollateJSON: Couldn't initialize ICU (%d)\n", (int)status); return -1; } } uiter_setUTF8(&iterA, str1, (int)len1); uiter_setUTF8(&iterB, str2, (int)len2); result = ucol_strcollIter(coll, &iterA, &iterB, &status); if (U_FAILURE(status)) { fprintf(stderr, "CouchStore CollateJSON: ICU error %d\n", (int)status); return -1; } if (result < 0) { return -1; } else if (result > 0) { return 1; } return 0; }
/* {{{ */ static void collator_ctor(INTERNAL_FUNCTION_PARAMETERS) { char* locale; int locale_len = 0; zval* object; Collator_object* co; intl_error_reset( NULL TSRMLS_CC ); object = return_value; /* Parse parameters. */ if( zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s", &locale, &locale_len ) == FAILURE ) { intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "collator_create: unable to parse input params", 0 TSRMLS_CC ); zval_dtor(return_value); RETURN_NULL(); } INTL_CHECK_LOCALE_LEN_OBJ(locale_len, return_value); co = (Collator_object *) zend_object_store_get_object( object TSRMLS_CC ); intl_error_reset( COLLATOR_ERROR_P( co ) TSRMLS_CC ); if(locale_len == 0) { locale = UG(default_locale); } /* Open ICU collator. */ co->ucoll = ucol_open( locale, COLLATOR_ERROR_CODE_P( co ) ); INTL_CTOR_CHECK_STATUS(co, "collator_create: unable to open ICU collator"); }
int on_load(ErlNifEnv* env, void** priv, ERL_NIF_TERM info) { UErrorCode status = U_ZERO_ERROR; int i, j; couch_ejson_global_ctx_t *globalCtx; globalCtx = (couch_ejson_global_ctx_t *) enif_alloc(sizeof(couch_ejson_global_ctx_t)); if (globalCtx == NULL) { return 1; } if (!enif_get_int(env, info, &globalCtx->numCollators)) { return 2; } if (globalCtx->numCollators < 1) { return 3; } globalCtx->collMutex = enif_mutex_create("coll_mutex"); if (globalCtx->collMutex == NULL) { return 4; } globalCtx->collators = (UCollator **) enif_alloc(sizeof(UCollator *) * globalCtx->numCollators); if (globalCtx->collators == NULL) { enif_mutex_destroy(globalCtx->collMutex); return 5; } for (i = 0; i < globalCtx->numCollators; i++) { globalCtx->collators[i] = ucol_open("", &status); if (U_FAILURE(status)) { for (j = 0; j < i; j++) { ucol_close(globalCtx->collators[j]); } enif_free(globalCtx->collators); enif_mutex_destroy(globalCtx->collMutex); return 5; } } globalCtx->collStackTop = 0; *priv = globalCtx; ATOM_TRUE = enif_make_atom(env, "true"); ATOM_FALSE = enif_make_atom(env, "false"); ATOM_NULL = enif_make_atom(env, "null"); ATOM_ERROR = enif_make_atom(env, "error"); return 0; }
U_CDECL_END #define LINES 6 void CollationThaiTest::TestInvalidThai(void) { const char *tests[LINES] = { "\\u0E44\\u0E01\\u0E44\\u0E01", "\\u0E44\\u0E01\\u0E01\\u0E44", "\\u0E01\\u0E44\\u0E01\\u0E44", "\\u0E01\\u0E01\\u0E44\\u0E44", "\\u0E44\\u0E44\\u0E01\\u0E01", "\\u0E01\\u0E44\\u0E44\\u0E01", }; UChar strings[LINES][20]; UChar *toSort[LINES]; int32_t i = 0, j = 0, len = 0; UErrorCode coll_status = U_ZERO_ERROR; UnicodeString iteratorText; thaiColl = ucol_open ("th_TH", &coll_status); if (U_FAILURE(coll_status)) { errln("Error opening Thai collator: %s", u_errorName(coll_status)); return; } CollationElementIterator* c = ((RuleBasedCollator *)coll)->createCollationElementIterator( iteratorText ); for(i = 0; i < (int32_t)(sizeof(tests)/sizeof(tests[0])); i++) { len = u_unescape(tests[i], strings[i], 20); strings[i][len] = 0; toSort[i] = strings[i]; } qsort (toSort, LINES, sizeof (UChar *), StrCmp); for (i=0; i < LINES; i++) { logln("%i", i); for (j=i+1; j < LINES; j++) { if (ucol_strcoll (thaiColl, toSort[i], -1, toSort[j], -1) == UCOL_GREATER) { // inconsistency ordering found! errln("Inconsistent ordering between strings %i and %i", i, j); } } iteratorText.setTo(toSort[i]); c->setText(iteratorText, coll_status); backAndForth(*c); } ucol_close(thaiColl); delete c; }
int main(int, char **) { UErrorCode status = U_ZERO_ERROR; UCollator *collator = ucol_open("ru_RU", &status); if (U_FAILURE(status)) return 0; ucol_close(collator); return 0; }
static jlong NativeCollation_openCollator(JNIEnv* env, jclass, jstring localeName) { ScopedUtfChars localeChars(env, localeName); if (localeChars.c_str() == NULL) { return 0; } UErrorCode status = U_ZERO_ERROR; UCollator* c = ucol_open(localeChars.c_str(), &status); maybeThrowIcuException(env, "ucol_open", status); return static_cast<jlong>(reinterpret_cast<uintptr_t>(c)); }
static jint NativeCollation_openCollator(JNIEnv* env, jclass, jstring localeName) { ScopedUtfChars localeChars(env, localeName); if (localeChars.c_str() == NULL) { return 0; } UErrorCode status = U_ZERO_ERROR; UCollator* c = ucol_open(localeChars.c_str(), &status); icu4jni_error(env, status); return static_cast<jint>(reinterpret_cast<uintptr_t>(c)); }
// Very simple example code - sticks a sortkey in the buffer // Not much error checking int32_t getSortKey_current(const char *locale, const UChar *string, int32_t sLen, uint8_t *buffer, int32_t bLen) { UErrorCode status = U_ZERO_ERROR; UCollator *coll = ucol_open(locale, &status); if(U_FAILURE(status)) { return -1; } int32_t result = ucol_getSortKey(coll, string, sLen, buffer, bLen); ucol_close(coll); return result; }
void c_Collator::t___construct(CStrRef locale) { INSTANCE_METHOD_INJECTION_BUILTIN(Collator, Collator::__construct); if (m_ucoll) { ucol_close(m_ucoll); m_ucoll = NULL; } m_errcode.clear(); if (!locale.empty()) { m_locale = locale; m_ucoll = ucol_open(locale.data(), &(m_errcode.code)); if (!U_FAILURE(m_errcode.code)) { // If the specified locale opened successfully, return s_intl_error->m_error.clear(); s_intl_error->m_error.code = m_errcode.code; return; } } // If the empty string was given or if the specified locale did // not open successfully, so fall back to using the default locale m_errcode.code = U_USING_FALLBACK_WARNING; s_intl_error->m_error.clear(); s_intl_error->m_error.code = m_errcode.code; if (m_ucoll) { ucol_close(m_ucoll); m_ucoll = NULL; } UErrorCode errcode = U_ZERO_ERROR; m_locale = String(uloc_getDefault(), CopyString); m_ucoll = ucol_open(m_locale.data(), &errcode); if (U_FAILURE(errcode)) { m_errcode.code = errcode; m_errcode.custom_error_message = "collator_create: unable to open ICU collator"; s_intl_error->m_error.clear(); s_intl_error->m_error.code = m_errcode.code; s_intl_error->m_error.custom_error_message = m_errcode.custom_error_message; if (m_ucoll) { ucol_close(m_ucoll); m_ucoll = NULL; } } }
static int compareUnicode(const char* str1, size_t len1, const char* str2, size_t len2) { static UCollator* coll = NULL; UChar *b1; UChar *b2; int ret1, ret2; int result; UErrorCode status = U_ZERO_ERROR; if (!coll) { coll = ucol_open("", &status); if (U_FAILURE(status)) { fprintf(stderr, "CouchStore CollateJSON: Couldn't initialize ICU (%d)\n", (int)status); return -1; } } if (len1 > 256 || len2 > 256) { return compareUnicodeSlow(str1, len1, str2, len2); } b1 = malloc(len1 * sizeof(UChar)); b2 = malloc(len2 * sizeof(UChar)); if (b1 == NULL || b2 == NULL) { free(b1); free(b2); fprintf(stderr, "CouchStore CollateJSON: Couldn't allocate memory\n"); return -2; } ret1 = convertUTF8toUChar(str1, b1, len1); ret2 = convertUTF8toUChar(str2, b2, len2); if (ret1 < 0 || ret2 < 0) { /* something went wrong with utf8->utf32 conversion */ free(b1); free(b2); return compareUnicodeSlow(str1, len1, str2, len2); } result = ucol_strcoll(coll, b1, len1, b2, len2); free(b1); free(b2); if (result < 0) { return -1; } else if (result > 0) { return 1; } return 0; }
/** * Create & set up an ICU Collator * * WARNING: this fuction is allowed to call the error() function. * Use before STRI__ERROR_HANDLER_BEGIN (with other prepareargs). * * @param opts_collator named R list * @return a Collator object that should be closed with ucol_close() after use * * * @version 0.1-?? (Marek Gagolewski) * * @version 0.2-1 (Marek Gagolewski, 2014-04-17) * allow for NULL opts_collator (identical to list()) * * @version 0.2-3 (Marek Gagolewski, 2014-05-09) * disallow NA as opts_collator * * @version 0.3-1 (Marek Gagolewski, 2014-11-05) * Issue #112: str_prepare_arg* retvals were not PROTECTed from gc; * + many other bugs in settings establishment * * @version 0.3-1 (Marek Gagolewski, 2014-11-06) * Fetch opts vals first to avoid memleaks (missing ucol_close calls on Rf_error) * * @version 0.4-1 (Marek Gagolewski, 2014-12-08) * #23: add `overlap` option */ UCollator* stri__ucol_open(SEXP opts_collator) { if (!isNull(opts_collator) && !Rf_isVectorList(opts_collator)) Rf_error(MSG__INCORRECT_COLLATOR_OPTION_SPEC); // error() allowed here R_len_t narg = isNull(opts_collator)?0:LENGTH(opts_collator); if (narg <= 0) { // no custom settings - use default Collator UErrorCode status = U_ZERO_ERROR; UCollator* col = ucol_open(NULL, &status); STRI__CHECKICUSTATUS_RFERROR(status, {/* do nothing special on err */}) // error() allowed here return col;