自学教程：C++ ucol_open函数代码示例

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 voidTestFCDCrash(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 voidTestFCDCrash(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_tsortkey_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");}

inton_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 6void 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 checkingint32_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;