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

static void TestUCharStringsEnumeration(void)  {  UErrorCode status = U_ZERO_ERROR;  /* //! [uenum_openUCharStringsEnumeration] */  static const UChar nko_1[] = {0x07c1,0}, nko_2[] = {0x07c2}, nko_3[] = {0x07c3,0}, nko_4[] = {0x07c4,0};  static const UChar* ustrings[] = {  nko_1, nko_2, nko_3, nko_4  };  UEnumeration *u = uenum_openUCharStringsEnumeration(ustrings, 4, &status);  /* //! [uenum_openUCharStringsEnumeration] */  if(U_FAILURE(status)) {    log_err("FAIL: could not open uchar strings enumeration: %s/n", u_errorName(status));    return;  }  verifyEnumeration(__LINE__, u, NULL, ustrings, 4);  uenum_close(u);  u =  uenum_openUCharStringsEnumeration(test2, 4, &status);  if(U_FAILURE(status)) {    log_err("FAIL: could not reopen uchar strings enumeration: %s/n", u_errorName(status));    return;  }  verifyEnumeration(__LINE__, u, test1, NULL, 4); /* same string */  uenum_close(u);  }

StringEnumeration* MeasureUnit::getAvailableTypes(UErrorCode &errorCode) {    UEnumeration *uenum = uenum_openCharStringsEnumeration(            gTypes, UPRV_LENGTHOF(gTypes), &errorCode);    if (U_FAILURE(errorCode)) {        uenum_close(uenum);        return NULL;    }    StringEnumeration *result = new UStringEnumeration(uenum);    if (result == NULL) {        errorCode = U_MEMORY_ALLOCATION_ERROR;        uenum_close(uenum);        return NULL;    }    return result;}

UStringEnumeration * U_EXPORT2UStringEnumeration::fromUEnumeration(        UEnumeration *uenumToAdopt, UErrorCode &status) {    if (U_FAILURE(status)) {        uenum_close(uenumToAdopt);        return NULL;    }    UStringEnumeration *result = new UStringEnumeration(uenumToAdopt);    if (result == NULL) {        status = U_MEMORY_ALLOCATION_ERROR;        uenum_close(uenumToAdopt);        return NULL;    }    return result;}

static void TestJ5298(void){    UErrorCode status = U_ZERO_ERROR;    char input[256], output[256];    UBool isAvailable;    int32_t i = 0;    UEnumeration* values = NULL;    const char *keywordValue = NULL;    log_verbose("Number of collator locales returned : %i /n", ucol_countAvailable());    values = ucol_getKeywordValues("collation", &status);    for (i = 0; i < ucol_countAvailable(); i++) {        uenum_reset(values, &status);        while ((keywordValue = uenum_next(values, NULL, &status)) != NULL) {            strcpy(input, ucol_getAvailable(i));            if (strcmp(keywordValue, "standard") != 0) {                strcat(input, "@collation=");                strcat(input, keywordValue);            }            ucol_getFunctionalEquivalent(output, 256, "collation", input, &isAvailable, &status);            if (strcmp(input, output) == 0) { /* Unique locale, print it out */                log_verbose("%s, /n", output);            }        }    }    uenum_close(values);    log_verbose("/n");}

static void TestGetContainedRegionsWithType() {    const KnownRegion * rd;    for (rd = knownRegions; rd->code != NULL ; rd++ ) {        UErrorCode status = U_ZERO_ERROR;        const URegion *r = uregion_getRegionFromCode(rd->code, &status);        if ( U_SUCCESS(status) ) {            UEnumeration *containedRegions;            const char *crID;            if (uregion_getType(r) != URGN_CONTINENT) {                continue;            }            containedRegions = uregion_getContainedRegionsOfType(r, URGN_TERRITORY, &status);            if (containedRegions) {                while ((crID = uenum_next(containedRegions, NULL, &status)) != NULL && U_SUCCESS(status) ) {                    const URegion *cr = uregion_getRegionFromCode(crID, &status);                    const URegion *containingRegion = (cr)? uregion_getContainingRegionOfType(cr, URGN_CONTINENT) : NULL;                    if ( !containingRegion || !uregion_areEqual(containingRegion, r) ) {                        log_err("ERROR: Continent: %s contains territory %s. Expected containing continent of this region to be the original region, but got %s/n",                            uregion_getRegionCode(r), uregion_getRegionCode(cr), (containingRegion)?uregion_getRegionCode(containingRegion):"NULL" );                     }                }                uenum_close(containedRegions);            }        } else {            log_data_err("ERROR: Known region %s was not recognized./n", rd->code);        }    }}

/*Function:GetCalendarsReturns the list of CalendarIds that are available for the specified locale.*/int32_t GlobalizationNative_GetCalendars(    const UChar* localeName, CalendarId* calendars, int32_t calendarsCapacity){    UErrorCode err = U_ZERO_ERROR;    char locale[ULOC_FULLNAME_CAPACITY];    GetLocale(localeName, locale, ULOC_FULLNAME_CAPACITY, FALSE, &err);    UEnumeration* pEnum = ucal_getKeywordValuesForLocale("calendar", locale, TRUE, &err);    int stringEnumeratorCount = uenum_count(pEnum, &err);    int calendarsReturned = 0;    for (int i = 0; i < stringEnumeratorCount && calendarsReturned < calendarsCapacity; i++)    {        int32_t calendarNameLength = 0;        const char* calendarName = uenum_next(pEnum, &calendarNameLength, &err);        if (U_SUCCESS(err))        {            CalendarId calendarId = GetCalendarId(calendarName);            if (calendarId != UNINITIALIZED_VALUE)            {                calendars[calendarsReturned] = calendarId;                calendarsReturned++;            }        }    }    uenum_close(pEnum);    return calendarsReturned;}

CFArrayRef CFLocaleCopyCommonISOCurrencyCodes(void) {    UErrorCode icuStatus = U_ZERO_ERROR;    UEnumeration *enumer = ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &icuStatus);    CFArrayRef result = __CFLocaleCopyUEnumerationAsArray(enumer, &icuStatus);    uenum_close(enumer);    return result;}

// get_available_transliterators {{{static PyObject *icu_get_available_transliterators(PyObject *self, PyObject *args) {    PyObject *ans, *l;    UErrorCode status = U_ZERO_ERROR;    const UChar *id = NULL;    UEnumeration *i;    ans = PyList_New(0);    if (ans == NULL) return PyErr_NoMemory();    i = utrans_openIDs(&status);    if (i == NULL || U_FAILURE(status)) {Py_DECREF(ans); PyErr_SetString(PyExc_RuntimeError, "Failed to create enumerator"); return NULL; }    do {        id = uenum_unext(i, NULL, &status);        if (U_SUCCESS(status) && id != NULL) {            l = uchar_to_unicode(id, -1);            if (l == NULL) break;            PyList_Append(ans, l);            Py_DECREF(l);        }    } while(id != NULL);    uenum_close(i);    return ans;}

static int32_t checkItemCount(uint32_t currencyType) {    UErrorCode status = U_ZERO_ERROR;    int32_t originalCount, count;    UEnumeration *en = ucurr_openISOCurrencies(currencyType, &status);    int32_t expectedLen = 3, len;    if (U_FAILURE(status)) {       log_err("Error: ucurr_openISOCurrencies returned %s/n", myErrorName(status));       return -1;    }    originalCount = uenum_count(en, &status);    for (count=0;;count++) {        const char *str = uenum_next(en, &len, &status);        if (str == NULL || len != expectedLen || strlen(str) != expectedLen) {            break;        }    }    if (originalCount != count) {        log_err("Error: uenum_count returned the wrong value (type = 0x%X). Got: %d Expected %d/n",           currencyType, count, originalCount);    }    if (U_FAILURE(status)) {        log_err("Error: uenum_next got an error: %s/n", u_errorName(status));    }    uenum_close(en);    return count;}

static void EmptyEnumerationTest(void) {    UErrorCode status = U_ZERO_ERROR;    UEnumeration *emptyEnum = uprv_malloc(sizeof(UEnumeration));    uprv_memcpy(emptyEnum, &emptyEnumerator, sizeof(UEnumeration));    if (uenum_count(emptyEnum, &status) != -1 || status != U_UNSUPPORTED_ERROR) {        log_err("uenum_count failed/n");    }    status = U_ZERO_ERROR;    if (uenum_next(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) {        log_err("uenum_next failed/n");    }    status = U_ZERO_ERROR;    if (uenum_unext(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) {        log_err("uenum_unext failed/n");    }    status = U_ZERO_ERROR;    uenum_reset(emptyEnum, &status);    if (status != U_UNSUPPORTED_ERROR) {        log_err("uenum_reset failed/n");    }    uenum_close(emptyEnum);    status = U_ZERO_ERROR;    if (uenum_next(NULL, NULL, &status) != NULL || status != U_ZERO_ERROR) {        log_err("uenum_next(NULL) failed/n");    }    status = U_ZERO_ERROR;    if (uenum_unext(NULL, NULL, &status) != NULL || status != U_ZERO_ERROR) {        log_err("uenum_unext(NULL) failed/n");    }    status = U_ZERO_ERROR;    uenum_reset(NULL, &status);    if (status != U_ZERO_ERROR) {        log_err("uenum_reset(NULL) failed/n");    }    emptyEnum = uprv_malloc(sizeof(UEnumeration));    uprv_memcpy(emptyEnum, &emptyPartialEnumerator, sizeof(UEnumeration));    status = U_ZERO_ERROR;    if (uenum_unext(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) {        log_err("partial uenum_unext failed/n");    }    uenum_close(emptyEnum);}

StringEnumeration*Collator::getKeywords(UErrorCode& status) {    // This is a wrapper over ucol_getKeywords    UEnumeration* uenum = ucol_getKeywords(&status);    if (U_FAILURE(status)) {        uenum_close(uenum);        return NULL;    }    return new UStringEnumeration(uenum);}

QSet<QByteArray> QIcuTimeZonePrivate::availableTimeZoneIds() const{    UErrorCode status = U_ZERO_ERROR;    UEnumeration *uenum = ucal_openTimeZones(&status);    QSet<QByteArray> set;    if (U_SUCCESS(status))        set = uenumToIdSet(uenum);    uenum_close(uenum);    return set;}

StringEnumeration* U_EXPORT2Collator::getKeywordValues(const char *keyword, UErrorCode& status) {    // This is a wrapper over ucol_getKeywordValues    UEnumeration* uenum = ucol_getKeywordValues(keyword, &status);    if (U_FAILURE(status)) {        uenum_close(uenum);        return NULL;    }    return new UStringEnumeration(uenum);}

static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {    UErrorCode status = U_ZERO_ERROR;    UEnumeration* e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));    EnumerationCounter counter(uenum_count(e, &status));    EnumerationGetter getter(e, &status);    jobject result = toStringArray16(env, &counter, &getter);    maybeThrowIcuException(env, status);    uenum_close(e);    return result;}

QSet<QByteArray> QIcuTimeZonePrivate::availableTimeZoneIds(QLocale::Country country) const{    QByteArray regionCode = QLocalePrivate::countryToCode(country).toUtf8();    UErrorCode status = U_ZERO_ERROR;    UEnumeration *uenum = ucal_openCountryTimeZones(regionCode, &status);    QSet<QByteArray> set;    if (U_SUCCESS(status))        set = uenumToIdSet(uenum);    uenum_close(uenum);    return set;}

StringEnumeration* U_EXPORT2Collator::getKeywordValuesForLocale(const char* key, const Locale& locale,                                    UBool commonlyUsed, UErrorCode& status) {    // This is a wrapper over ucol_getKeywordValuesForLocale    UEnumeration *uenum = ucol_getKeywordValuesForLocale(key, locale.getName(),                                                        commonlyUsed, &status);    if (U_FAILURE(status)) {        uenum_close(uenum);        return NULL;    }    return new UStringEnumeration(uenum);}

static UBool doTestNames(const char *name, const char *standard, const char **expected, int32_t size) {    UErrorCode err = U_ZERO_ERROR;    UEnumeration *myEnum = ucnv_openStandardNames(name, standard, &err);    const char *enumName, *testName;    int32_t enumCount = uenum_count(myEnum, &err);    int32_t idx, len, repeatTimes = 3;        if (err == U_FILE_ACCESS_ERROR) {        log_data_err("Unable to open standard names for %s of standard: %s/n", name, standard);        return 0;    }    if (size != enumCount) {        log_err("FAIL: different size arrays for %s. Got %d. Expected %d/n", name, enumCount, size);        return 0;    }    if (size < 0 && myEnum) {        log_err("FAIL: size < 0, but recieved an actual object/n");        return 0;    }    log_verbose("/n%s %s/n", name, standard);    while (repeatTimes-- > 0) {        for (idx = 0; idx < enumCount; idx++) {            enumName = uenum_next(myEnum, &len, &err);            testName = expected[idx];            if (uprv_strcmp(enumName, testName) != 0 || U_FAILURE(err)                || len != (int32_t)uprv_strlen(expected[idx]))            {                log_err("FAIL: uenum_next(%d) == /"%s/". expected /"%s/", len=%d, error=%s/n",                    idx, enumName, testName, len, u_errorName(err));            }            log_verbose("%s/n", enumName);            err = U_ZERO_ERROR;        }        if (enumCount >= 0) {            /* one past the list of all names must return NULL */            enumName = uenum_next(myEnum, &len, &err);            if (enumName != NULL || len != 0 || U_FAILURE(err)) {                log_err("FAIL: uenum_next(past the list) did not return NULL[0] with U_SUCCESS(). name=%s standard=%s len=%d err=%s/n", name, standard, len, u_errorName(err));            }        }        log_verbose("/n    reset/n");        uenum_reset(myEnum, &err);        if (U_FAILURE(err)) {            log_err("FAIL: uenum_reset() for %s{%s} failed with %s/n",                name, standard, u_errorName(err));            err = U_ZERO_ERROR;        }    }    uenum_close(myEnum);    return 1;}

static ERL_NIF_TERM get_trans_ids(ErlNifEnv* env, UErrorCode& status){    ERL_NIF_TERM out;    UEnumeration* en;    en = utrans_openIDs(&status);    CHECK(env, status);    out = enum_to_term(env, en);    uenum_close(en);    return out;}

static Variant HHVM_STATIC_METHOD(IntlCalendar, getKeywordValuesForLocale,                                 const String& key, const String& locale,                                 bool common) {  UErrorCode error = U_ZERO_ERROR;  UEnumeration *uenum = ucal_getKeywordValuesForLocale(key.c_str(),                                   ULOC_DEFAULT(locale).c_str(),                                   common, &error);  if (U_FAILURE(error)) {    if (uenum) { uenum_close(uenum); }    s_intl_error->set(error, "intlcal_get_keyword_values_for_locale: "                             "error calling underlying method");    return false;  }  return IntlIterator::newInstance(new BugStringCharEnumeration(uenum));}

static void TestCharStringsEnumeration(void)  {  UErrorCode status = U_ZERO_ERROR;  /* //! [uenum_openCharStringsEnumeration] */  const char* strings[] = { "Firstly", "Secondly", "Thirdly", "Fourthly" };  UEnumeration *u = uenum_openCharStringsEnumeration(strings, 4, &status);  /* //! [uenum_openCharStringsEnumeration] */  if(U_FAILURE(status)) {    log_err("FAIL: could not open char strings enumeration: %s/n", u_errorName(status));    return;  }  verifyEnumeration(__LINE__, u, strings, NULL, 4);  uenum_close(u);}

QSet<QByteArray> QIcuTimeZonePrivate::availableTimeZoneIds(int offsetFromUtc) const{// TODO Available directly in C++ api but not C api, from 4.8 onwards new filter method works#if U_ICU_VERSION_MAJOR_NUM >= 49 || (U_ICU_VERSION_MAJOR_NUM == 4 && U_ICU_VERSION_MINOR_NUM == 8)    UErrorCode status = U_ZERO_ERROR;    UEnumeration *uenum = ucal_openTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, 0,                                                         &offsetFromUtc, &status);    QSet<QByteArray> set;    if (U_SUCCESS(status))        set = uenumToIdSet(uenum);    uenum_close(uenum);    return set;#else    return QTimeZonePrivate::availableTimeZoneIds(offsetFromUtc);#endif}

static void EnumerationTest(void) {    UErrorCode status = U_ZERO_ERROR;    int32_t len = 0;    UEnumeration *en = getchArrayEnum(test1, sizeof(test1)/sizeof(test1[0]));    const char *string = NULL;    const UChar *uString = NULL;    while ((string = uenum_next(en, &len, &status))) {        log_verbose("read /"%s/", length %i/n", string, len);    }    uenum_reset(en, &status);    while ((uString = uenum_unext(en, &len, &status))) {        log_verbose("read /"%s/" (UChar), length %i/n", quikU2C(uString, len), len);    }        uenum_close(en);}

/** * call-seq: *     UCalendar.time_zones * * Returns array with all time zones (as UString values).  */VALUE icu4r_cal_all_tz (VALUE obj){	UErrorCode  status = U_ZERO_ERROR;	UEnumeration * zones ; 	VALUE ret ;	UChar * name;	int32_t len;	zones = ucal_openTimeZones (&status);	ICU_RAISE(status);	ret = rb_ary_new();	while( (name = (UChar*)uenum_unext(zones, &len, &status))) {		rb_ary_push(ret, icu_ustr_new(name, len));	}	uenum_close(zones);	return ret;}

static Variant HHVM_STATIC_METHOD(Locale, acceptFromHttp,                                  const String& header) {  UErrorCode error = U_ZERO_ERROR;  UEnumeration *avail = ures_openAvailableLocales(nullptr, &error);  ULOC_CHECK(error, false);  char out[MAX_LOCALE_LEN];  UAcceptResult result;  error = U_ZERO_ERROR;  int len = uloc_acceptLanguageFromHTTP(out, sizeof(out), &result,                                        header.c_str(), avail, &error);  uenum_close(avail);  ULOC_CHECK(error, false);  if (len < 0 || result == ULOC_ACCEPT_FAILED) {    return false;  }  return String(out, len, CopyString);}

static UBool doTestUCharNames(const char *name, const char *standard, const char **expected, int32_t size) {    UErrorCode err = U_ZERO_ERROR;    UEnumeration *myEnum = ucnv_openStandardNames(name, standard, &err);    int32_t enumCount = uenum_count(myEnum, &err);    int32_t idx, repeatTimes = 3;        if (err == U_FILE_ACCESS_ERROR) {        log_data_err("Unable to open standard names for %s of standard: %s/n", name, standard);        return 0;    }        if (size != enumCount) {        log_err("FAIL: different size arrays. Got %d. Expected %d/n", enumCount, size);        return 0;    }    if (size < 0 && myEnum) {        log_err("FAIL: size < 0, but recieved an actual object/n");        return 0;    }    log_verbose("/n%s %s/n", name, standard);    while (repeatTimes-- > 0) {        for (idx = 0; idx < enumCount; idx++) {            UChar testName[256];            int32_t len;            const UChar *enumName = uenum_unext(myEnum, &len, &err);            u_uastrncpy(testName, expected[idx], UPRV_LENGTHOF(testName));            if (u_strcmp(enumName, testName) != 0 || U_FAILURE(err)                || len != (int32_t)uprv_strlen(expected[idx]))            {                log_err("FAIL: uenum_next(%d) == /"%s/". expected /"%s/", len=%d, error=%s/n",                    idx, enumName, testName, len, u_errorName(err));            }            log_verbose("%s/n", expected[idx]);            err = U_ZERO_ERROR;        }        log_verbose("/n    reset/n");        uenum_reset(myEnum, &err);        if (U_FAILURE(err)) {            log_err("FAIL: uenum_reset() for %s{%s} failed with %s/n",                name, standard, u_errorName(err));            err = U_ZERO_ERROR;        }    }    uenum_close(myEnum);    return 1;}

/** * call-seq: *     UCalendar.tz_for_country(country) *   * Returns array with all time zones associated with the given country. * Note: <code>country</code> must be value of type String. * Returned array content is UString's * *     UCalendar.tz_for_country("GB") # => [ "Europe/Belfast", "Europe/London", "GB",  "GB-Eire"] * */VALUE icu4r_cal_country_tz (VALUE obj, VALUE ctry){	UErrorCode  status = U_ZERO_ERROR;	UEnumeration * zones ; 	VALUE ret ;	UChar * name;	int32_t len;	Check_Type(ctry, T_STRING);	zones = ucal_openCountryTimeZones (RSTRING_PTR(ctry), &status) ;	ICU_RAISE(status);	ret = rb_ary_new();	while( (name = (UChar*)uenum_unext(zones, &len, &status))) {		rb_ary_push(ret, icu_ustr_new(name, len));	}	uenum_close(zones);	return ret;}

ERL_NIF_TERM trans_ids(ErlNifEnv* env, int argc,     const ERL_NIF_TERM /*argv*/[]){    ERL_NIF_TERM out;    UEnumeration* en;     UErrorCode status = U_ZERO_ERROR;    if (argc != 0)        return enif_make_badarg(env);    en = utrans_openIDs(&status);       CHECK(env, status);    out = enum_to_term(env, en);    uenum_close(en);    return out;}

static Vector<String> sortLocaleData(const String& locale, size_t keyIndex){    // 9.1 Internal slots of Service Constructors & 10.2.3 Internal slots (ECMA-402 2.0)    Vector<String> keyLocaleData;    switch (keyIndex) {    case indexOfExtensionKeyCo: {        // 10.2.3 "The first element of [[sortLocaleData]][locale].co and [[searchLocaleData]][locale].co must be null for all locale values."        keyLocaleData.append({ });        UErrorCode status = U_ZERO_ERROR;        UEnumeration* enumeration = ucol_getKeywordValuesForLocale("collation", locale.utf8().data(), false, &status);        if (U_SUCCESS(status)) {            const char* collation;            while ((collation = uenum_next(enumeration, nullptr, &status)) && U_SUCCESS(status)) {                // 10.2.3 "The values "standard" and "search" must not be used as elements in any [[sortLocaleData]][locale].co and [[searchLocaleData]][locale].co array."                if (!strcmp(collation, "standard") || !strcmp(collation, "search"))                    continue;                // Map keyword values to BCP 47 equivalents.                if (!strcmp(collation, "dictionary"))                    collation = "dict";                else if (!strcmp(collation, "gb2312han"))                    collation = "gb2312";                else if (!strcmp(collation, "phonebook"))                    collation = "phonebk";                else if (!strcmp(collation, "traditional"))                    collation = "trad";                keyLocaleData.append(collation);            }            uenum_close(enumeration);        }        break;    }    case indexOfExtensionKeyKn:        keyLocaleData.reserveInitialCapacity(2);        keyLocaleData.uncheckedAppend(ASCIILiteral("false"));        keyLocaleData.uncheckedAppend(ASCIILiteral("true"));        break;    default:        ASSERT_NOT_REACHED();    }    return keyLocaleData;}