virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
UErrorCode &errorCode) {
ResourceTable contexts = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
for (int i = 0; contexts.getKeyAndValue(i, key, value); ++i) {
CapContextUsage usageEnum;
if (uprv_strcmp(key, "key") == 0) {
usageEnum = kCapContextUsageKey;
} else if (uprv_strcmp(key, "keyValue") == 0) {
usageEnum = kCapContextUsageKeyValue;
} else if (uprv_strcmp(key, "languages") == 0) {
usageEnum = kCapContextUsageLanguage;
} else if (uprv_strcmp(key, "script") == 0) {
usageEnum = kCapContextUsageScript;
} else if (uprv_strcmp(key, "territory") == 0) {
usageEnum = kCapContextUsageTerritory;
} else if (uprv_strcmp(key, "variant") == 0) {
usageEnum = kCapContextUsageVariant;
} else {
continue;
}
int32_t len = 0;
const int32_t* intVector = value.getIntVector(len, errorCode);
if (U_FAILURE(errorCode)) { return; }
if (len < 2) { continue; }
int32_t titlecaseInt = (parent.capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU) ? intVector[0] : intVector[1];
if (titlecaseInt == 0) { continue; }
parent.fCapitalization[usageEnum] = TRUE;
hasCapitalizationUsage = TRUE;
}
}
virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) {
ResourceTable dayPeriodData = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
for (int32_t i = 0; dayPeriodData.getKeyAndValue(i, key, value); ++i) {
if (uprv_strcmp(key, "locales") == 0) {
ResourceTable locales = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
for (int32_t j = 0; locales.getKeyAndValue(j, key, value); ++j) {
UnicodeString setNum_str = value.getUnicodeString(errorCode);
int32_t setNum = parseSetNum(setNum_str, errorCode);
uhash_puti(data->localeToRuleSetNumMap, const_cast<char *>(key), setNum, &errorCode);
}
} else if (uprv_strcmp(key, "rules") == 0) {
// Allocate one more than needed to skip [0]. See comment in parseSetNum().
data->rules = new DayPeriodRules[data->maxRuleSetNum + 1];
if (data->rules == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
return;
}
ResourceTable rules = value.getTable(errorCode);
processRules(rules, key, value, errorCode);
if (U_FAILURE(errorCode)) { return; }
}
}
}
virtual void put(const char *key, const ResourceValue &value, UErrorCode &errorCode) {
if (U_FAILURE(errorCode)) { return; }
UnicodeString setNum_str = value.getUnicodeString(errorCode);
int32_t setNum = parseSetNum(setNum_str, errorCode);
uhash_puti(data->localeToRuleSetNumMap, const_cast<char *>(key), setNum, &errorCode);
}
virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) {
ResourceTable rules = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
for (int32_t i = 0; rules.getKeyAndValue(i, key, value); ++i) {
int32_t setNum = DayPeriodRulesDataSink::parseSetNum(key, errorCode);
if (setNum > data->maxRuleSetNum) {
data->maxRuleSetNum = setNum;
}
}
}
void processRules(const ResourceTable &rules, const char *key,
ResourceValue &value, UErrorCode &errorCode) {
if (U_FAILURE(errorCode)) { return; }
for (int32_t i = 0; rules.getKeyAndValue(i, key, value); ++i) {
ruleSetNum = parseSetNum(key, errorCode);
ResourceTable ruleSet = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
for (int32_t j = 0; ruleSet.getKeyAndValue(j, key, value); ++j) {
period = DayPeriodRules::getDayPeriodFromString(key);
if (period == DayPeriodRules::DAYPERIOD_UNKNOWN) {
errorCode = U_INVALID_FORMAT_ERROR;
return;
}
ResourceTable periodDefinition = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
for (int32_t k = 0; periodDefinition.getKeyAndValue(k, key, value); ++k) {
if (value.getType() == URES_STRING) {
// Key-value pairs (e.g. before{6:00}).
CutoffType type = getCutoffTypeFromString(key);
addCutoff(type, value.getUnicodeString(errorCode), errorCode);
if (U_FAILURE(errorCode)) { return; }
} else {
// Arrays (e.g. before{6:00, 24:00}).
cutoffType = getCutoffTypeFromString(key);
ResourceArray cutoffArray = value.getArray(errorCode);
if (U_FAILURE(errorCode)) { return; }
int32_t length = cutoffArray.getSize();
for (int32_t l = 0; l < length; ++l) {
cutoffArray.getValue(l, value);
addCutoff(cutoffType, value.getUnicodeString(errorCode), errorCode);
if (U_FAILURE(errorCode)) { return; }
}
}
}
setDayPeriodForHoursFromCutoffs(errorCode);
for (int32_t k = 0; k < UPRV_LENGTHOF(cutoffs); ++k) {
cutoffs[k] = 0;
}
}
if (!data->rules[ruleSetNum].allHoursAreSet()) {
errorCode = U_INVALID_FORMAT_ERROR;
return;
}
}
}
virtual void put(int32_t, const ResourceValue &value, UErrorCode &errorCode) {
outer.addCutoff(outer.cutoffType, value.getUnicodeString(errorCode), errorCode);
}
virtual void put(const char *key, const ResourceValue &value, UErrorCode &errorCode) {
if (U_FAILURE(errorCode)) { return; }
CutoffType type = getCutoffTypeFromString(key);
outer.addCutoff(type, value.getUnicodeString(errorCode), errorCode);
}
void CompactData::CompactDataSink::put(const char *key, ResourceValue &value, UBool /*noFallback*/,
UErrorCode &status) {
// traverse into the table of powers of ten
ResourceTable powersOfTenTable = value.getTable(status);
if (U_FAILURE(status)) { return; }
for (int i3 = 0; powersOfTenTable.getKeyAndValue(i3, key, value); ++i3) {
// Assumes that the keys are always of the form "10000" where the magnitude is the
// length of the key minus one. We expect magnitudes to be less than MAX_DIGITS.
auto magnitude = static_cast<int8_t> (strlen(key) - 1);
int8_t multiplier = data.multipliers[magnitude];
U_ASSERT(magnitude < COMPACT_MAX_DIGITS);
// Iterate over the plural variants ("one", "other", etc)
ResourceTable pluralVariantsTable = value.getTable(status);
if (U_FAILURE(status)) { return; }
for (int i4 = 0; pluralVariantsTable.getKeyAndValue(i4, key, value); ++i4) {
// Skip this magnitude/plural if we already have it from a child locale.
// Note: This also skips USE_FALLBACK entries.
StandardPlural::Form plural = StandardPlural::fromString(key, status);
if (U_FAILURE(status)) { return; }
if (data.patterns[getIndex(magnitude, plural)] != nullptr) {
continue;
}
// The value "0" means that we need to use the default pattern and not fall back
// to parent locales. Example locale where this is relevant: 'it'.
int32_t patternLength;
const UChar *patternString = value.getString(patternLength, status);
if (U_FAILURE(status)) { return; }
if (u_strcmp(patternString, u"0") == 0) {
patternString = USE_FALLBACK;
patternLength = 0;
}
// Save the pattern string. We will parse it lazily.
data.patterns[getIndex(magnitude, plural)] = patternString;
// If necessary, compute the multiplier: the difference between the magnitude
// and the number of zeros in the pattern.
if (multiplier == 0) {
int32_t numZeros = countZeros(patternString, patternLength);
if (numZeros > 0) { // numZeros==0 in certain cases, like Somali "Kun"
multiplier = static_cast<int8_t> (numZeros - magnitude - 1);
}
}
}
// Save the multiplier.
if (data.multipliers[magnitude] == 0) {
data.multipliers[magnitude] = multiplier;
if (magnitude > data.largestMagnitude) {
data.largestMagnitude = magnitude;
}
data.isEmpty = false;
} else {
U_ASSERT(data.multipliers[magnitude] == multiplier);
}
}
}