const NFRule*
NFRuleSet::findDoubleRule(double number) const
{
// if this is a fraction rule set, use findFractionRuleSetRule()
if (isFractionRuleSet()) {
return findFractionRuleSetRule(number);
}
if (uprv_isNaN(number)) {
const NFRule *rule = nonNumericalRules[NAN_RULE_INDEX];
if (!rule) {
rule = owner->getDefaultNaNRule();
}
return rule;
}
// if the number is negative, return the negative number rule
// (if there isn't a negative-number rule, we pretend it's a
// positive number)
if (number < 0) {
if (nonNumericalRules[NEGATIVE_RULE_INDEX]) {
return nonNumericalRules[NEGATIVE_RULE_INDEX];
} else {
number = -number;
}
}
if (uprv_isInfinite(number)) {
const NFRule *rule = nonNumericalRules[INFINITY_RULE_INDEX];
if (!rule) {
rule = owner->getDefaultInfinityRule();
}
return rule;
}
// if the number isn't an integer, we use one of the fraction rules...
if (number != uprv_floor(number)) {
// if the number is between 0 and 1, return the proper
// fraction rule
if (number < 1 && nonNumericalRules[PROPER_FRACTION_RULE_INDEX]) {
return nonNumericalRules[PROPER_FRACTION_RULE_INDEX];
}
// otherwise, return the improper fraction rule
else if (nonNumericalRules[IMPROPER_FRACTION_RULE_INDEX]) {
return nonNumericalRules[IMPROPER_FRACTION_RULE_INDEX];
}
}
// if there's a master rule, use it to format the number
if (nonNumericalRules[MASTER_RULE_INDEX]) {
return nonNumericalRules[MASTER_RULE_INDEX];
}
// and if we haven't yet returned a rule, use findNormalRule()
// to find the applicable rule
int64_t r = util64_fromDouble(number + 0.5);
return findNormalRule(r);
}
void
NFRuleSet::format(int64_t number, UnicodeString& toAppendTo, int32_t pos, int32_t recursionCount, UErrorCode& status) const
{
if (recursionCount >= RECURSION_LIMIT) {
// stop recursion
status = U_INVALID_STATE_ERROR;
return;
}
const NFRule *rule = findNormalRule(number);
if (rule) { // else error, but can't report it
rule->doFormat(number, toAppendTo, pos, ++recursionCount, status);
}
}
NFRule *
NFRuleSet::findDoubleRule(double number) const
{
// if this is a fraction rule set, use findFractionRuleSetRule()
if (isFractionRuleSet())
{
return findFractionRuleSetRule(number);
}
// if the number is negative, return the negative number rule
// (if there isn't a negative-number rule, we pretend it's a
// positive number)
if (number < 0)
{
if (negativeNumberRule)
{
return negativeNumberRule;
}
else
{
number = -number;
}
}
// if the number isn't an integer, we use one of the fraction rules...
if (number != uprv_floor(number))
{
// if the number is between 0 and 1, return the proper
// fraction rule
if (number < 1 && fractionRules[1])
{
return fractionRules[1];
}
// otherwise, return the improper fraction rule
else if (fractionRules[0])
{
return fractionRules[0];
}
}
// if there's a master rule, use it to format the number
if (fractionRules[2])
{
return fractionRules[2];
}
// and if we haven't yet returned a rule, use findNormalRule()
// to find the applicable rule
int64_t r = util64_fromDouble(number + 0.5);
return findNormalRule(r);
}
void
NFRuleSet::format(int64_t number, UnicodeString& toAppendTo, int32_t pos, UErrorCode& status) const
{
NFRule *rule = findNormalRule(number);
if (rule) { // else error, but can't report it
NFRuleSet* ncThis = (NFRuleSet*)this;
if (ncThis->fRecursionCount++ >= RECURSION_LIMIT) {
// stop recursion
ncThis->fRecursionCount = 0;
} else {
rule->doFormat(number, toAppendTo, pos, status);
ncThis->fRecursionCount--;
}
}
}