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_EXPORT2
UStringEnumeration::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 Vector<String> localeData(const String& locale, size_t keyIndex)
{
Vector<String> keyLocaleData;
switch (keyIndex) {
case indexOfExtensionKeyCa: {
UErrorCode status = U_ZERO_ERROR;
UEnumeration* calendars = ucal_getKeywordValuesForLocale("calendar", locale.utf8().data(), false, &status);
ASSERT(U_SUCCESS(status));
int32_t nameLength;
while (const char* availableName = uenum_next(calendars, &nameLength, &status)) {
ASSERT(U_SUCCESS(status));
String calendar = String(availableName, nameLength);
keyLocaleData.append(calendar);
// Ensure aliases used in language tag are allowed.
if (calendar == "gregorian")
keyLocaleData.append(ASCIILiteral("gregory"));
else if (calendar == "islamic-civil")
keyLocaleData.append(ASCIILiteral("islamicc"));
else if (calendar == "ethiopic-amete-alem")
keyLocaleData.append(ASCIILiteral("ethioaa"));
}
uenum_close(calendars);
break;
}
case indexOfExtensionKeyNu:
keyLocaleData = numberingSystemsForLocale(locale);
break;
default:
ASSERT_NOT_REACHED();
}
return keyLocaleData;
}
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:
GetCalendars
Returns 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_EXPORT2
Collator::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_EXPORT2
Collator::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 String canonicalizeTimeZoneName(const String& timeZoneName)
{
// 6.4.1 IsValidTimeZoneName (timeZone)
// The abstract operation returns true if timeZone, converted to upper case as described in 6.1, is equal to one of the Zone or Link names of the IANA Time Zone Database, converted to upper case as described in 6.1. It returns false otherwise.
UErrorCode status = U_ZERO_ERROR;
UEnumeration* timeZones = ucal_openTimeZones(&status);
ASSERT(U_SUCCESS(status));
String canonical;
do {
status = U_ZERO_ERROR;
int32_t ianaTimeZoneLength;
// Time zone names are respresented as UChar[] in all related ICU apis.
const UChar* ianaTimeZone = uenum_unext(timeZones, &ianaTimeZoneLength, &status);
ASSERT(U_SUCCESS(status));
// End of enumeration.
if (!ianaTimeZone)
break;
StringView ianaTimeZoneView(ianaTimeZone, ianaTimeZoneLength);
if (!equalIgnoringASCIICase(timeZoneName, ianaTimeZoneView))
continue;
// Found a match, now canonicalize.
// 6.4.2 CanonicalizeTimeZoneName (timeZone) (ECMA-402 2.0)
// 1. Let ianaTimeZone be the Zone or Link name of the IANA Time Zone Database such that timeZone, converted to upper case as described in 6.1, is equal to ianaTimeZone, converted to upper case as described in 6.1.
// 2. If ianaTimeZone is a Link name, then let ianaTimeZone be the corresponding Zone name as specified in the “backward” file of the IANA Time Zone Database.
Vector<UChar, 32> buffer(ianaTimeZoneLength);
status = U_ZERO_ERROR;
auto canonicalLength = ucal_getCanonicalTimeZoneID(ianaTimeZone, ianaTimeZoneLength, buffer.data(), ianaTimeZoneLength, nullptr, &status);
if (status == U_BUFFER_OVERFLOW_ERROR) {
buffer.grow(canonicalLength);
status = U_ZERO_ERROR;
ucal_getCanonicalTimeZoneID(ianaTimeZone, ianaTimeZoneLength, buffer.data(), canonicalLength, nullptr, &status);
}
ASSERT(U_SUCCESS(status));
canonical = String(buffer.data(), canonicalLength);
} while (canonical.isNull());
uenum_close(timeZones);
// 3. If ianaTimeZone is "Etc/UTC" or "Etc/GMT", then return "UTC".
if (canonical == "Etc/UTC" || canonical == "Etc/GMT")
canonical = ASCIILiteral("UTC");
// 4. Return ianaTimeZone.
return canonical;
}
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;
}
