UBool MeasureFormat::operator==(const Format &other) const {
if (this == &other) { // Same object, equal
return TRUE;
}
if (!Format::operator==(other)) {
return FALSE;
}
const MeasureFormat &rhs = static_cast<const MeasureFormat &>(other);
// Note: Since the ListFormatter depends only on Locale and width, we
// don't have to check it here.
// differing widths aren't equivalent
if (fWidth != rhs.fWidth) {
return FALSE;
}
// Width the same check locales.
// We don't need to check locales if both objects have same cache.
if (cache != rhs.cache) {
UErrorCode status = U_ZERO_ERROR;
const char *localeId = getLocaleID(status);
const char *rhsLocaleId = rhs.getLocaleID(status);
if (U_FAILURE(status)) {
// On failure, assume not equal
return FALSE;
}
if (uprv_strcmp(localeId, rhsLocaleId) != 0) {
return FALSE;
}
}
// Locales same, check NumberFormat if shared data differs.
return (
numberFormat == rhs.numberFormat ||
**numberFormat == **rhs.numberFormat);
}
void
TimeUnitFormat::checkConsistency(UTimeUnitFormatStyle style, const char* key, UErrorCode& err) {
if (U_FAILURE(err)) {
return;
}
// there should be patterns for each plural rule in each time unit.
// For each time unit,
// for each plural rule, following is unit pattern fall-back rule:
// ( for example: "one" hour )
// look for its unit pattern in its locale tree.
// if pattern is not found in its own locale, such as de_DE,
// look for the pattern in its parent, such as de,
// keep looking till found or till root.
// if the pattern is not found in root either,
// fallback to plural count "other",
// look for the pattern of "other" in the locale tree:
// "de_DE" to "de" to "root".
// If not found, fall back to value of
// static variable DEFAULT_PATTERN_FOR_xxx, such as "{0} h".
//
// Following is consistency check to create pattern for each
// plural rule in each time unit using above fall-back rule.
//
StringEnumeration* keywords = getPluralRules().getKeywords(err);
if (U_SUCCESS(err)) {
const UnicodeString* pluralCount;
while ((pluralCount = keywords->snext(err)) != NULL) {
if ( U_SUCCESS(err) ) {
for (int32_t i = 0; i < TimeUnit::UTIMEUNIT_FIELD_COUNT; ++i) {
// for each time unit,
// get all the patterns for each plural rule in this locale.
Hashtable* countToPatterns = fTimeUnitToCountToPatterns[i];
if ( countToPatterns == NULL ) {
countToPatterns = initHash(err);
if (U_FAILURE(err)) {
delete countToPatterns;
return;
}
fTimeUnitToCountToPatterns[i] = countToPatterns;
}
MessageFormat** formatters = (MessageFormat**)countToPatterns->get(*pluralCount);
if( formatters == NULL || formatters[style] == NULL ) {
// look through parents
const char* localeName = getLocaleID(err);
CharString pluralCountChars;
pluralCountChars.appendInvariantChars(*pluralCount, err);
searchInLocaleChain(style, key, localeName,
(TimeUnit::UTimeUnitFields)i,
*pluralCount, pluralCountChars.data(),
countToPatterns, err);
}
}
}
}
}
delete keywords;
}
void NumberFormat::getEffectiveCurrency(UChar* result, UErrorCode& ec) const {
const UChar* c = getCurrency();
if (*c != 0) {
u_strncpy(result, c, 3);
result[3] = 0;
} else {
const char* loc = getLocaleID(ULOC_VALID_LOCALE, ec);
if (loc == NULL) {
loc = uloc_getDefault();
}
ucurr_forLocale(loc, result, 4, &ec);
}
}
int main(int argv, char** argc){
char* in = (char*)malloc(sizeof(char)*100);
int a = 0;
while(a != EOF){
a = scanf("%s",in);
FILE* f = fopen(in,"r");
// printf("%s",f);
getLocaleID("",f);
#ifdef debug
printf("%s\n",in);
#endif
}
return 1;
}
U_NAMESPACE_BEGIN
Locale LocaleBased::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
const char* id = getLocaleID(type, status);
return Locale((id != 0) ? id : "");
}
void
TimeUnitFormat::readFromCurrentLocale(UTimeUnitFormatStyle style, const char* key,
const UVector& pluralCounts, UErrorCode& err) {
if (U_FAILURE(err)) {
return;
}
// fill timeUnitToCountToPatterns from resource file
// err is used to indicate wrong status except missing resource.
// status is an error code used in resource lookup.
// status does not affect "err".
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *rb, *unitsRes;
rb = ures_open(U_ICUDATA_UNIT, getLocaleID(status), &status);
unitsRes = ures_getByKey(rb, key, NULL, &status);
unitsRes = ures_getByKey(unitsRes, "duration", unitsRes, &status);
if (U_FAILURE(status)) {
ures_close(unitsRes);
ures_close(rb);
return;
}
int32_t size = ures_getSize(unitsRes);
for ( int32_t index = 0; index < size; ++index) {
// resource of one time unit
UResourceBundle* oneTimeUnit = ures_getByIndex(unitsRes, index,
NULL, &status);
if (U_SUCCESS(status)) {
const char* timeUnitName = ures_getKey(oneTimeUnit);
if (timeUnitName == NULL) {
ures_close(oneTimeUnit);
continue;
}
UResourceBundle* countsToPatternRB = ures_getByKey(unitsRes,
timeUnitName,
NULL, &status);
if (countsToPatternRB == NULL || U_FAILURE(status)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
continue;
}
TimeUnit::UTimeUnitFields timeUnitField = TimeUnit::UTIMEUNIT_FIELD_COUNT;
if ( uprv_strcmp(timeUnitName, gTimeUnitYear) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_YEAR;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitMonth) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_MONTH;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitDay) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_DAY;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitHour) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_HOUR;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitMinute) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_MINUTE;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitSecond) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_SECOND;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitWeek) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_WEEK;
} else {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
continue;
}
Hashtable* countToPatterns = fTimeUnitToCountToPatterns[timeUnitField];
if (countToPatterns == NULL) {
countToPatterns = initHash(err);
if (U_FAILURE(err)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
delete countToPatterns;
break;
}
}
int32_t count = ures_getSize(countsToPatternRB);
const char* pluralCount;
for ( int32_t pluralIndex = 0; pluralIndex < count; ++pluralIndex) {
// resource of count to pattern
UnicodeString pattern =
ures_getNextUnicodeString(countsToPatternRB, &pluralCount, &status);
if (U_FAILURE(status)) {
continue;
}
UnicodeString pluralCountUniStr(pluralCount, -1, US_INV);
if (!pluralCounts.contains(&pluralCountUniStr)) {
continue;
}
MessageFormat* messageFormat = new MessageFormat(pattern, getLocale(err), err);
if ( U_SUCCESS(err) ) {
MessageFormat** formatters = (MessageFormat**)countToPatterns->get(pluralCountUniStr);
if (formatters == NULL) {
formatters = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*));
formatters[UTMUTFMT_FULL_STYLE] = NULL;
formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL;
countToPatterns->put(pluralCountUniStr, formatters, err);
if (U_FAILURE(err)) {
uprv_free(formatters);
}
}
if (U_SUCCESS(err)) {
//delete formatters[style];
formatters[style] = messageFormat;
}
}
if (U_FAILURE(err)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
ures_close(unitsRes);
ures_close(rb);
delete messageFormat;
delete countToPatterns;
return;
}
}
if (fTimeUnitToCountToPatterns[timeUnitField] == NULL) {
fTimeUnitToCountToPatterns[timeUnitField] = countToPatterns;
}
ures_close(countsToPatternRB);
}
ures_close(oneTimeUnit);
}
ures_close(unitsRes);
ures_close(rb);
}