[apple/icu.git] / icuSources / i18n / numrange_impl.cpp

// © 2018 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

// Allow implicit conversion from char16_t* to UnicodeString for this file:
// Helpful in toString methods and elsewhere.
#define UNISTR_FROM_STRING_EXPLICIT

#include "unicode/numberrangeformatter.h"
#include "numrange_impl.h"
#include "patternprops.h"
#include "uresimp.h"
#include "util.h"

using namespace icu;
using namespace icu::number;
using namespace icu::number::impl;

namespace {

// Helper function for 2-dimensional switch statement
constexpr int8_t identity2d(UNumberRangeIdentityFallback a, UNumberRangeIdentityResult b) {
    return static_cast<int8_t>(a) | (static_cast<int8_t>(b) << 4);
}


struct NumberRangeData {
    SimpleFormatter rangePattern;
    SimpleFormatter approximatelyPattern;
};

class NumberRangeDataSink : public ResourceSink {
  public:
    NumberRangeDataSink(NumberRangeData& data) : fData(data) {}

    void put(const char* key, ResourceValue& value, UBool /*noFallback*/, UErrorCode& status) U_OVERRIDE {
        ResourceTable miscTable = value.getTable(status);
        if (U_FAILURE(status)) { return; }
        for (int i = 0; miscTable.getKeyAndValue(i, key, value); i++) {
            if (uprv_strcmp(key, "range") == 0) {
                if (hasRangeData()) {
                    continue; // have already seen this pattern
                }
                fData.rangePattern = {value.getUnicodeString(status), status};
            } else if (uprv_strcmp(key, "approximately") == 0) {
                if (hasApproxData()) {
                    continue; // have already seen this pattern
                }
                fData.approximatelyPattern = {value.getUnicodeString(status), status};
            }
        }
    }

    bool hasRangeData() {
        return fData.rangePattern.getArgumentLimit() != 0;
    }

    bool hasApproxData() {
        return fData.approximatelyPattern.getArgumentLimit() != 0;
    }

    bool isComplete() {
        return hasRangeData() && hasApproxData();
    }

    void fillInDefaults(UErrorCode& status) {
        if (!hasRangeData()) {
            fData.rangePattern = {u"{0}–{1}", status};
        }
        if (!hasApproxData()) {
            fData.approximatelyPattern = {u"~{0}", status};
        }
    }

  private:
    NumberRangeData& fData;
};

void getNumberRangeData(const char* localeName, const char* nsName, NumberRangeData& data, UErrorCode& status) {
    if (U_FAILURE(status)) { return; }
    LocalUResourceBundlePointer rb(ures_open(NULL, localeName, &status));
    if (U_FAILURE(status)) { return; }
    NumberRangeDataSink sink(data);

    CharString dataPath;
    dataPath.append("NumberElements/", -1, status);
    dataPath.append(nsName, -1, status);
    dataPath.append("/miscPatterns", -1, status);
    if (U_FAILURE(status)) { return; }

    UErrorCode localStatus = U_ZERO_ERROR;
    ures_getAllItemsWithFallback(rb.getAlias(), dataPath.data(), sink, localStatus);
    if (U_FAILURE(localStatus) && localStatus != U_MISSING_RESOURCE_ERROR) {
        status = localStatus;
        return;
    }

    // Fall back to latn if necessary
    if (!sink.isComplete()) {
        ures_getAllItemsWithFallback(rb.getAlias(), "NumberElements/latn/miscPatterns", sink, status);
    }

    sink.fillInDefaults(status);
}

class PluralRangesDataSink : public ResourceSink {
  public:
    PluralRangesDataSink(StandardPluralRanges& output) : fOutput(output) {}

    void put(const char* /*key*/, ResourceValue& value, UBool /*noFallback*/, UErrorCode& status) U_OVERRIDE {
        ResourceArray entriesArray = value.getArray(status);
        if (U_FAILURE(status)) { return; }
        fOutput.setCapacity(entriesArray.getSize());
        for (int i = 0; entriesArray.getValue(i, value); i++) {
            ResourceArray pluralFormsArray = value.getArray(status);
            if (U_FAILURE(status)) { return; }
            pluralFormsArray.getValue(0, value);
            StandardPlural::Form first = StandardPlural::fromString(value.getUnicodeString(status), status);
            if (U_FAILURE(status)) { return; }
            pluralFormsArray.getValue(1, value);
            StandardPlural::Form second = StandardPlural::fromString(value.getUnicodeString(status), status);
            if (U_FAILURE(status)) { return; }
            pluralFormsArray.getValue(2, value);
            StandardPlural::Form result = StandardPlural::fromString(value.getUnicodeString(status), status);
            if (U_FAILURE(status)) { return; }
            fOutput.addPluralRange(first, second, result);
        }
    }

  private:
    StandardPluralRanges& fOutput;
};

void getPluralRangesData(const Locale& locale, StandardPluralRanges& output, UErrorCode& status) {
    if (U_FAILURE(status)) { return; }
    LocalUResourceBundlePointer rb(ures_openDirect(nullptr, "pluralRanges", &status));
    if (U_FAILURE(status)) { return; }

    CharString dataPath;
    dataPath.append("locales/", -1, status);
    dataPath.append(locale.getLanguage(), -1, status);
    if (U_FAILURE(status)) { return; }
    int32_t setLen;
    // Not all languages are covered: fail gracefully
    UErrorCode internalStatus = U_ZERO_ERROR;
    const UChar* set = ures_getStringByKeyWithFallback(rb.getAlias(), dataPath.data(), &setLen, &internalStatus);
    if (U_FAILURE(internalStatus)) { return; }

    dataPath.clear();
    dataPath.append("rules/", -1, status);
    dataPath.appendInvariantChars(set, setLen, status);
    if (U_FAILURE(status)) { return; }
    PluralRangesDataSink sink(output);
    ures_getAllItemsWithFallback(rb.getAlias(), dataPath.data(), sink, status);
    if (U_FAILURE(status)) { return; }
}

} // namespace


void StandardPluralRanges::initialize(const Locale& locale, UErrorCode& status) {
    getPluralRangesData(locale, *this, status);
}

void StandardPluralRanges::addPluralRange(
        StandardPlural::Form first,
        StandardPlural::Form second,
        StandardPlural::Form result) {
    U_ASSERT(fTriplesLen < fTriples.getCapacity());
    fTriples[fTriplesLen] = {first, second, result};
    fTriplesLen++;
}

void StandardPluralRanges::setCapacity(int32_t length) {
    if (length > fTriples.getCapacity()) {
        fTriples.resize(length, 0);
    }
}

StandardPlural::Form
StandardPluralRanges::resolve(StandardPlural::Form first, StandardPlural::Form second) const {
    for (int32_t i=0; i<fTriplesLen; i++) {
        const auto& triple = fTriples[i];
        if (triple.first == first && triple.second == second) {
            return triple.result;
        }
    }
    // Default fallback
    return StandardPlural::OTHER;
}


NumberRangeFormatterImpl::NumberRangeFormatterImpl(const RangeMacroProps& macros, UErrorCode& status)
    : formatterImpl1(macros.formatter1.fMacros, status),
      formatterImpl2(macros.formatter2.fMacros, status),
      fSameFormatters(macros.singleFormatter),
      fCollapse(macros.collapse),
      fIdentityFallback(macros.identityFallback) {

    const char* nsName = formatterImpl1.getRawMicroProps().nsName;
    if (uprv_strcmp(nsName, formatterImpl2.getRawMicroProps().nsName) != 0) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }

    NumberRangeData data;
    getNumberRangeData(macros.locale.getName(), nsName, data, status);
    if (U_FAILURE(status)) { return; }
    fRangeFormatter = data.rangePattern;
    fApproximatelyModifier = {data.approximatelyPattern, UNUM_FIELD_COUNT, false};

    // TODO: Get locale from PluralRules instead?
    fPluralRanges.initialize(macros.locale, status);
    if (U_FAILURE(status)) { return; }
}

void NumberRangeFormatterImpl::format(UFormattedNumberRangeData& data, bool equalBeforeRounding, UErrorCode& status) const {
    if (U_FAILURE(status)) {
        return;
    }

    MicroProps micros1;
    MicroProps micros2;
    formatterImpl1.preProcess(data.quantity1, micros1, status);
    if (fSameFormatters) {
        formatterImpl1.preProcess(data.quantity2, micros2, status);
    } else {
        formatterImpl2.preProcess(data.quantity2, micros2, status);
    }
    if (U_FAILURE(status)) {
        return;
    }

    // If any of the affixes are different, an identity is not possible
    // and we must use formatRange().
    // TODO: Write this as MicroProps operator==() ?
    // TODO: Avoid the redundancy of these equality operations with the
    // ones in formatRange?
    if (!micros1.modInner->semanticallyEquivalent(*micros2.modInner)
            || !micros1.modMiddle->semanticallyEquivalent(*micros2.modMiddle)
            || !micros1.modOuter->semanticallyEquivalent(*micros2.modOuter)) {
        formatRange(data, micros1, micros2, status);
        data.identityResult = UNUM_IDENTITY_RESULT_NOT_EQUAL;
        return;
    }

    // Check for identity
    if (equalBeforeRounding) {
        data.identityResult = UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING;
    } else if (data.quantity1 == data.quantity2) {
        data.identityResult = UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING;
    } else {
        data.identityResult = UNUM_IDENTITY_RESULT_NOT_EQUAL;
    }

    switch (identity2d(fIdentityFallback, data.identityResult)) {
        case identity2d(UNUM_IDENTITY_FALLBACK_RANGE,
                        UNUM_IDENTITY_RESULT_NOT_EQUAL):
        case identity2d(UNUM_IDENTITY_FALLBACK_RANGE,
                        UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING):
        case identity2d(UNUM_IDENTITY_FALLBACK_RANGE,
                        UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING):
        case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY,
                        UNUM_IDENTITY_RESULT_NOT_EQUAL):
        case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY_OR_SINGLE_VALUE,
                        UNUM_IDENTITY_RESULT_NOT_EQUAL):
        case identity2d(UNUM_IDENTITY_FALLBACK_SINGLE_VALUE,
                        UNUM_IDENTITY_RESULT_NOT_EQUAL):
            formatRange(data, micros1, micros2, status);
            break;

        case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY,
                        UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING):
        case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY,
                        UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING):
        case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY_OR_SINGLE_VALUE,
                        UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING):
            formatApproximately(data, micros1, micros2, status);
            break;

        case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY_OR_SINGLE_VALUE,
                        UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING):
        case identity2d(UNUM_IDENTITY_FALLBACK_SINGLE_VALUE,
                        UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING):
        case identity2d(UNUM_IDENTITY_FALLBACK_SINGLE_VALUE,
                        UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING):
            formatSingleValue(data, micros1, micros2, status);
            break;

        default:
            UPRV_UNREACHABLE;
    }
}


void NumberRangeFormatterImpl::formatSingleValue(UFormattedNumberRangeData& data,
                                                 MicroProps& micros1, MicroProps& micros2,
                                                 UErrorCode& status) const {
    if (U_FAILURE(status)) { return; }
    if (fSameFormatters) {
        int32_t length = NumberFormatterImpl::writeNumber(micros1, data.quantity1, data.getStringRef(), 0, status);
        NumberFormatterImpl::writeAffixes(micros1, data.getStringRef(), 0, length, status);
    } else {
        formatRange(data, micros1, micros2, status);
    }
}


void NumberRangeFormatterImpl::formatApproximately (UFormattedNumberRangeData& data,
                                                    MicroProps& micros1, MicroProps& micros2,
                                                    UErrorCode& status) const {
    if (U_FAILURE(status)) { return; }
    if (fSameFormatters) {
        int32_t length = NumberFormatterImpl::writeNumber(micros1, data.quantity1, data.getStringRef(), 0, status);
        // HEURISTIC: Desired modifier order: inner, middle, approximately, outer.
        length += micros1.modInner->apply(data.getStringRef(), 0, length, status);
        length += micros1.modMiddle->apply(data.getStringRef(), 0, length, status);
        length += fApproximatelyModifier.apply(data.getStringRef(), 0, length, status);
        micros1.modOuter->apply(data.getStringRef(), 0, length, status);
    } else {
        formatRange(data, micros1, micros2, status);
    }
}


void NumberRangeFormatterImpl::formatRange(UFormattedNumberRangeData& data,
                                           MicroProps& micros1, MicroProps& micros2,
                                           UErrorCode& status) const {
    if (U_FAILURE(status)) { return; }

    // modInner is always notation (scientific); collapsable in ALL.
    // modOuter is always units; collapsable in ALL, AUTO, and UNIT.
    // modMiddle could be either; collapsable in ALL and sometimes AUTO and UNIT.
    // Never collapse an outer mod but not an inner mod.
    bool collapseOuter, collapseMiddle, collapseInner;
    switch (fCollapse) {
        case UNUM_RANGE_COLLAPSE_ALL:
        case UNUM_RANGE_COLLAPSE_AUTO:
        case UNUM_RANGE_COLLAPSE_UNIT:
        {
            // OUTER MODIFIER
            collapseOuter = micros1.modOuter->semanticallyEquivalent(*micros2.modOuter);

            if (!collapseOuter) {
                // Never collapse inner mods if outer mods are not collapsable
                collapseMiddle = false;
                collapseInner = false;
                break;
            }

            // MIDDLE MODIFIER
            collapseMiddle = micros1.modMiddle->semanticallyEquivalent(*micros2.modMiddle);

            if (!collapseMiddle) {
                // Never collapse inner mods if outer mods are not collapsable
                collapseInner = false;
                break;
            }

            // MIDDLE MODIFIER HEURISTICS
            // (could disable collapsing of the middle modifier)
            // The modifiers are equal by this point, so we can look at just one of them.
            const Modifier* mm = micros1.modMiddle;
            if (fCollapse == UNUM_RANGE_COLLAPSE_UNIT) {
                // Only collapse if the modifier is a unit.
                // TODO: Make a better way to check for a unit?
                // TODO: Handle case where the modifier has both notation and unit (compact currency)?
                if (!mm->containsField(UNUM_CURRENCY_FIELD) && !mm->containsField(UNUM_PERCENT_FIELD)) {
                    collapseMiddle = false;
                }
            } else if (fCollapse == UNUM_RANGE_COLLAPSE_AUTO) {
                // Heuristic as of ICU 63: collapse only if the modifier is more than one code point.
                if (mm->getCodePointCount() <= 1) {
                    collapseMiddle = false;
                }
            }

            if (!collapseMiddle || fCollapse != UNUM_RANGE_COLLAPSE_ALL) {
                collapseInner = false;
                break;
            }

            // INNER MODIFIER
            collapseInner = micros1.modInner->semanticallyEquivalent(*micros2.modInner);

            // All done checking for collapsability.
            break;
        }

        default:
            collapseOuter = false;
            collapseMiddle = false;
            collapseInner = false;
            break;
    }

    NumberStringBuilder& string = data.getStringRef();
    int32_t lengthPrefix = 0;
    int32_t length1 = 0;
    int32_t lengthInfix = 0;
    int32_t length2 = 0;
    int32_t lengthSuffix = 0;

    // Use #define so that these are evaluated at the call site.
    #define UPRV_INDEX_0 (lengthPrefix)
    #define UPRV_INDEX_1 (lengthPrefix + length1)
    #define UPRV_INDEX_2 (lengthPrefix + length1 + lengthInfix)
    #define UPRV_INDEX_3 (lengthPrefix + length1 + lengthInfix + length2)

    int32_t lengthRange = SimpleModifier::formatTwoArgPattern(
        fRangeFormatter,
        string,
        0,
        &lengthPrefix,
        &lengthSuffix,
        UNUM_FIELD_COUNT,
        status);
    if (U_FAILURE(status)) { return; }
    lengthInfix = lengthRange - lengthPrefix - lengthSuffix;
    U_ASSERT(lengthInfix > 0);

    // SPACING HEURISTIC
    // Add spacing unless all modifiers are collapsed.
    // TODO: add API to control this?
    // TODO: Use a data-driven heuristic like currency spacing?
    // TODO: Use Unicode [:whitespace:] instead of PatternProps whitespace? (consider speed implications)
    {
        bool repeatInner = !collapseInner && micros1.modInner->getCodePointCount() > 0;
        bool repeatMiddle = !collapseMiddle && micros1.modMiddle->getCodePointCount() > 0;
        bool repeatOuter = !collapseOuter && micros1.modOuter->getCodePointCount() > 0;
        if (repeatInner || repeatMiddle || repeatOuter) {
            // Add spacing if there is not already spacing
            if (!PatternProps::isWhiteSpace(string.charAt(UPRV_INDEX_1))) {
                lengthInfix += string.insertCodePoint(UPRV_INDEX_1, u'\u0020', UNUM_FIELD_COUNT, status);
            }
            if (!PatternProps::isWhiteSpace(string.charAt(UPRV_INDEX_2 - 1))) {
                lengthInfix += string.insertCodePoint(UPRV_INDEX_2, u'\u0020', UNUM_FIELD_COUNT, status);
            }
        }
    }

    length1 += NumberFormatterImpl::writeNumber(micros1, data.quantity1, string, UPRV_INDEX_0, status);
    length2 += NumberFormatterImpl::writeNumber(micros2, data.quantity2, string, UPRV_INDEX_2, status);

    // TODO: Support padding?

    if (collapseInner) {
        // Note: this is actually a mix of prefix and suffix, but adding to infix length works
        const Modifier& mod = resolveModifierPlurals(*micros1.modInner, *micros2.modInner);
        lengthInfix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_3, status);
    } else {
        length1 += micros1.modInner->apply(string, UPRV_INDEX_0, UPRV_INDEX_1, status);
        length2 += micros2.modInner->apply(string, UPRV_INDEX_2, UPRV_INDEX_3, status);
    }

    if (collapseMiddle) {
        // Note: this is actually a mix of prefix and suffix, but adding to infix length works
        const Modifier& mod = resolveModifierPlurals(*micros1.modMiddle, *micros2.modMiddle);
        lengthInfix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_3, status);
    } else {
        length1 += micros1.modMiddle->apply(string, UPRV_INDEX_0, UPRV_INDEX_1, status);
        length2 += micros2.modMiddle->apply(string, UPRV_INDEX_2, UPRV_INDEX_3, status);
    }

    if (collapseOuter) {
        // Note: this is actually a mix of prefix and suffix, but adding to infix length works
        const Modifier& mod = resolveModifierPlurals(*micros1.modOuter, *micros2.modOuter);
        lengthInfix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_3, status);
    } else {
        length1 += micros1.modOuter->apply(string, UPRV_INDEX_0, UPRV_INDEX_1, status);
        length2 += micros2.modOuter->apply(string, UPRV_INDEX_2, UPRV_INDEX_3, status);
    }
}


const Modifier&
NumberRangeFormatterImpl::resolveModifierPlurals(const Modifier& first, const Modifier& second) const {
    Modifier::Parameters parameters;
    first.getParameters(parameters);
    if (parameters.obj == nullptr) {
        // No plural form; return a fallback (e.g., the first)
        return first;
    }
    StandardPlural::Form firstPlural = parameters.plural;

    second.getParameters(parameters);
    if (parameters.obj == nullptr) {
        // No plural form; return a fallback (e.g., the first)
        return first;
    }
    StandardPlural::Form secondPlural = parameters.plural;

    // Get the required plural form from data
    StandardPlural::Form resultPlural = fPluralRanges.resolve(firstPlural, secondPlural);

    // Get and return the new Modifier
    const Modifier* mod = parameters.obj->getModifier(parameters.signum, resultPlural);
    U_ASSERT(mod != nullptr);
    return *mod;
}


#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
3d1f044b A	1	// © 2018 and later: Unicode, Inc. and others.
	2	// License & terms of use: http://www.unicode.org/copyright.html
	3
	4	#include "unicode/utypes.h"
	5
	6	#if !UCONFIG_NO_FORMATTING
	7
	8	// Allow implicit conversion from char16_t* to UnicodeString for this file:
	9	// Helpful in toString methods and elsewhere.
	10	#define UNISTR_FROM_STRING_EXPLICIT
	11
	12	#include "unicode/numberrangeformatter.h"
	13	#include "numrange_impl.h"
	14	#include "patternprops.h"
	15	#include "uresimp.h"
	16	#include "util.h"
	17
	18	using namespace icu;
	19	using namespace icu::number;
	20	using namespace icu::number::impl;
	21
	22	namespace {
	23
	24	// Helper function for 2-dimensional switch statement
	25	constexpr int8_t identity2d(UNumberRangeIdentityFallback a, UNumberRangeIdentityResult b) {
	26	return static_cast<int8_t>(a) \| (static_cast<int8_t>(b) << 4);
	27	}
	28
	29
	30	struct NumberRangeData {
	31	SimpleFormatter rangePattern;
	32	SimpleFormatter approximatelyPattern;
	33	};
	34
	35	class NumberRangeDataSink : public ResourceSink {
	36	public:
	37	NumberRangeDataSink(NumberRangeData& data) : fData(data) {}
	38
	39	void put(const char* key, ResourceValue& value, UBool /noFallback/, UErrorCode& status) U_OVERRIDE {
	40	ResourceTable miscTable = value.getTable(status);
	41	if (U_FAILURE(status)) { return; }
	42	for (int i = 0; miscTable.getKeyAndValue(i, key, value); i++) {
	43	if (uprv_strcmp(key, "range") == 0) {
	44	if (hasRangeData()) {
	45	continue; // have already seen this pattern
	46	}
	47	fData.rangePattern = {value.getUnicodeString(status), status};
	48	} else if (uprv_strcmp(key, "approximately") == 0) {
	49	if (hasApproxData()) {
	50	continue; // have already seen this pattern
	51	}
	52	fData.approximatelyPattern = {value.getUnicodeString(status), status};
	53	}
	54	}
	55	}
	56
	57	bool hasRangeData() {
	58	return fData.rangePattern.getArgumentLimit() != 0;
	59	}
	60
	61	bool hasApproxData() {
	62	return fData.approximatelyPattern.getArgumentLimit() != 0;
	63	}
	64
65	bool isComplete() {
66	return hasRangeData() && hasApproxData();
67	}
68
69	void fillInDefaults(UErrorCode& status) {
70	if (!hasRangeData()) {
71	fData.rangePattern = {u"{0}–{1}", status};
72	}
73	if (!hasApproxData()) {
74	fData.approximatelyPattern = {u"~{0}", status};
75	}
76	}
77
78	private:
79	NumberRangeData& fData;
80	};
81
82	void getNumberRangeData(const char* localeName, const char* nsName, NumberRangeData& data, UErrorCode& status) {
83	if (U_FAILURE(status)) { return; }
84	LocalUResourceBundlePointer rb(ures_open(NULL, localeName, &status));
85	if (U_FAILURE(status)) { return; }
86	NumberRangeDataSink sink(data);
87
88	CharString dataPath;
89	dataPath.append("NumberElements/", -1, status);
90	dataPath.append(nsName, -1, status);
91	dataPath.append("/miscPatterns", -1, status);
92	if (U_FAILURE(status)) { return; }
93
94	UErrorCode localStatus = U_ZERO_ERROR;
95	ures_getAllItemsWithFallback(rb.getAlias(), dataPath.data(), sink, localStatus);
96	if (U_FAILURE(localStatus) && localStatus != U_MISSING_RESOURCE_ERROR) {
97	status = localStatus;
98	return;
99	}
100
101	// Fall back to latn if necessary
102	if (!sink.isComplete()) {
103	ures_getAllItemsWithFallback(rb.getAlias(), "NumberElements/latn/miscPatterns", sink, status);
104	}
105
106	sink.fillInDefaults(status);
107	}
108
109	class PluralRangesDataSink : public ResourceSink {
110	public:
111	PluralRangesDataSink(StandardPluralRanges& output) : fOutput(output) {}
112
113	void put(const char* /key/, ResourceValue& value, UBool /noFallback/, UErrorCode& status) U_OVERRIDE {
114	ResourceArray entriesArray = value.getArray(status);
115	if (U_FAILURE(status)) { return; }
116	fOutput.setCapacity(entriesArray.getSize());
117	for (int i = 0; entriesArray.getValue(i, value); i++) {
118	ResourceArray pluralFormsArray = value.getArray(status);
119	if (U_FAILURE(status)) { return; }
120	pluralFormsArray.getValue(0, value);
121	StandardPlural::Form first = StandardPlural::fromString(value.getUnicodeString(status), status);
122	if (U_FAILURE(status)) { return; }
123	pluralFormsArray.getValue(1, value);
124	StandardPlural::Form second = StandardPlural::fromString(value.getUnicodeString(status), status);
125	if (U_FAILURE(status)) { return; }
126	pluralFormsArray.getValue(2, value);
127	StandardPlural::Form result = StandardPlural::fromString(value.getUnicodeString(status), status);
128	if (U_FAILURE(status)) { return; }
129	fOutput.addPluralRange(first, second, result);
130	}
131	}
132
133	private:
134	StandardPluralRanges& fOutput;
135	};
136
137	void getPluralRangesData(const Locale& locale, StandardPluralRanges& output, UErrorCode& status) {
138	if (U_FAILURE(status)) { return; }
139	LocalUResourceBundlePointer rb(ures_openDirect(nullptr, "pluralRanges", &status));
140	if (U_FAILURE(status)) { return; }
141
142	CharString dataPath;
143	dataPath.append("locales/", -1, status);
144	dataPath.append(locale.getLanguage(), -1, status);
145	if (U_FAILURE(status)) { return; }
146	int32_t setLen;
147	// Not all languages are covered: fail gracefully
148	UErrorCode internalStatus = U_ZERO_ERROR;
149	const UChar* set = ures_getStringByKeyWithFallback(rb.getAlias(), dataPath.data(), &setLen, &internalStatus);
150	if (U_FAILURE(internalStatus)) { return; }
151
152	dataPath.clear();
153	dataPath.append("rules/", -1, status);
154	dataPath.appendInvariantChars(set, setLen, status);
155	if (U_FAILURE(status)) { return; }
156	PluralRangesDataSink sink(output);
157	ures_getAllItemsWithFallback(rb.getAlias(), dataPath.data(), sink, status);
158	if (U_FAILURE(status)) { return; }
159	}
160
161	} // namespace
162
163
164	void StandardPluralRanges::initialize(const Locale& locale, UErrorCode& status) {
165	getPluralRangesData(locale, *this, status);
166	}
167
168	void StandardPluralRanges::addPluralRange(
169	StandardPlural::Form first,
170	StandardPlural::Form second,
171	StandardPlural::Form result) {
172	U_ASSERT(fTriplesLen < fTriples.getCapacity());
173	fTriples[fTriplesLen] = {first, second, result};
174	fTriplesLen++;
175	}
176
177	void StandardPluralRanges::setCapacity(int32_t length) {
178	if (length > fTriples.getCapacity()) {
179	fTriples.resize(length, 0);
180	}
181	}
182
183	StandardPlural::Form
184	StandardPluralRanges::resolve(StandardPlural::Form first, StandardPlural::Form second) const {
185	for (int32_t i=0; i<fTriplesLen; i++) {
186	const auto& triple = fTriples[i];
187	if (triple.first == first && triple.second == second) {
188	return triple.result;
189	}
190	}
191	// Default fallback
192	return StandardPlural::OTHER;
193	}
194
195
196	NumberRangeFormatterImpl::NumberRangeFormatterImpl(const RangeMacroProps& macros, UErrorCode& status)
197	: formatterImpl1(macros.formatter1.fMacros, status),
198	formatterImpl2(macros.formatter2.fMacros, status),
199	fSameFormatters(macros.singleFormatter),
200	fCollapse(macros.collapse),
201	fIdentityFallback(macros.identityFallback) {
202
203	const char* nsName = formatterImpl1.getRawMicroProps().nsName;
204	if (uprv_strcmp(nsName, formatterImpl2.getRawMicroProps().nsName) != 0) {
205	status = U_ILLEGAL_ARGUMENT_ERROR;
206	return;
207	}
208
209	NumberRangeData data;
210	getNumberRangeData(macros.locale.getName(), nsName, data, status);
211	if (U_FAILURE(status)) { return; }
212	fRangeFormatter = data.rangePattern;
213	fApproximatelyModifier = {data.approximatelyPattern, UNUM_FIELD_COUNT, false};
214
215	// TODO: Get locale from PluralRules instead?
216	fPluralRanges.initialize(macros.locale, status);
217	if (U_FAILURE(status)) { return; }
218	}
219
220	void NumberRangeFormatterImpl::format(UFormattedNumberRangeData& data, bool equalBeforeRounding, UErrorCode& status) const {
221	if (U_FAILURE(status)) {
222	return;
223	}
224
225	MicroProps micros1;
226	MicroProps micros2;
227	formatterImpl1.preProcess(data.quantity1, micros1, status);
228	if (fSameFormatters) {
229	formatterImpl1.preProcess(data.quantity2, micros2, status);
230	} else {
231	formatterImpl2.preProcess(data.quantity2, micros2, status);
232	}
233	if (U_FAILURE(status)) {
234	return;
235	}
236
237	// If any of the affixes are different, an identity is not possible
238	// and we must use formatRange().
239	// TODO: Write this as MicroProps operator==() ?
240	// TODO: Avoid the redundancy of these equality operations with the
241	// ones in formatRange?
242	if (!micros1.modInner->semanticallyEquivalent(*micros2.modInner)
243	\|\| !micros1.modMiddle->semanticallyEquivalent(*micros2.modMiddle)
244	\|\| !micros1.modOuter->semanticallyEquivalent(*micros2.modOuter)) {
245	formatRange(data, micros1, micros2, status);
246	data.identityResult = UNUM_IDENTITY_RESULT_NOT_EQUAL;
247	return;
248	}
249
250	// Check for identity
251	if (equalBeforeRounding) {
252	data.identityResult = UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING;
253	} else if (data.quantity1 == data.quantity2) {
254	data.identityResult = UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING;
255	} else {
256	data.identityResult = UNUM_IDENTITY_RESULT_NOT_EQUAL;
257	}
258
259	switch (identity2d(fIdentityFallback, data.identityResult)) {
260	case identity2d(UNUM_IDENTITY_FALLBACK_RANGE,
261	UNUM_IDENTITY_RESULT_NOT_EQUAL):
262	case identity2d(UNUM_IDENTITY_FALLBACK_RANGE,
263	UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING):
264	case identity2d(UNUM_IDENTITY_FALLBACK_RANGE,
265	UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING):
266	case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY,
267	UNUM_IDENTITY_RESULT_NOT_EQUAL):
268	case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY_OR_SINGLE_VALUE,
269	UNUM_IDENTITY_RESULT_NOT_EQUAL):
270	case identity2d(UNUM_IDENTITY_FALLBACK_SINGLE_VALUE,
271	UNUM_IDENTITY_RESULT_NOT_EQUAL):
272	formatRange(data, micros1, micros2, status);
273	break;
274
275	case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY,
276	UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING):
277	case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY,
278	UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING):
279	case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY_OR_SINGLE_VALUE,
280	UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING):
281	formatApproximately(data, micros1, micros2, status);
282	break;
283
284	case identity2d(UNUM_IDENTITY_FALLBACK_APPROXIMATELY_OR_SINGLE_VALUE,
285	UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING):
286	case identity2d(UNUM_IDENTITY_FALLBACK_SINGLE_VALUE,
287	UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING):
288	case identity2d(UNUM_IDENTITY_FALLBACK_SINGLE_VALUE,
289	UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING):
290	formatSingleValue(data, micros1, micros2, status);
291	break;
292
293	default:
294	UPRV_UNREACHABLE;
295	}
296	}
297
298
299	void NumberRangeFormatterImpl::formatSingleValue(UFormattedNumberRangeData& data,
300	MicroProps& micros1, MicroProps& micros2,
301	UErrorCode& status) const {
302	if (U_FAILURE(status)) { return; }
303	if (fSameFormatters) {
304	int32_t length = NumberFormatterImpl::writeNumber(micros1, data.quantity1, data.getStringRef(), 0, status);
305	NumberFormatterImpl::writeAffixes(micros1, data.getStringRef(), 0, length, status);
306	} else {
307	formatRange(data, micros1, micros2, status);
308	}
309	}
310
311
312	void NumberRangeFormatterImpl::formatApproximately (UFormattedNumberRangeData& data,
313	MicroProps& micros1, MicroProps& micros2,
314	UErrorCode& status) const {
315	if (U_FAILURE(status)) { return; }
316	if (fSameFormatters) {
317	int32_t length = NumberFormatterImpl::writeNumber(micros1, data.quantity1, data.getStringRef(), 0, status);
318	// HEURISTIC: Desired modifier order: inner, middle, approximately, outer.
319	length += micros1.modInner->apply(data.getStringRef(), 0, length, status);
320	length += micros1.modMiddle->apply(data.getStringRef(), 0, length, status);
321	length += fApproximatelyModifier.apply(data.getStringRef(), 0, length, status);
322	micros1.modOuter->apply(data.getStringRef(), 0, length, status);
323	} else {
324	formatRange(data, micros1, micros2, status);
325	}
326	}
327
328
329	void NumberRangeFormatterImpl::formatRange(UFormattedNumberRangeData& data,
330	MicroProps& micros1, MicroProps& micros2,
331	UErrorCode& status) const {
332	if (U_FAILURE(status)) { return; }
333
334	// modInner is always notation (scientific); collapsable in ALL.
335	// modOuter is always units; collapsable in ALL, AUTO, and UNIT.
336	// modMiddle could be either; collapsable in ALL and sometimes AUTO and UNIT.
337	// Never collapse an outer mod but not an inner mod.
338	bool collapseOuter, collapseMiddle, collapseInner;
339	switch (fCollapse) {
340	case UNUM_RANGE_COLLAPSE_ALL:
341	case UNUM_RANGE_COLLAPSE_AUTO:
342	case UNUM_RANGE_COLLAPSE_UNIT:
343	{
344	// OUTER MODIFIER
345	collapseOuter = micros1.modOuter->semanticallyEquivalent(*micros2.modOuter);
346
347	if (!collapseOuter) {
348	// Never collapse inner mods if outer mods are not collapsable
349	collapseMiddle = false;
350	collapseInner = false;
351	break;
352	}
353
354	// MIDDLE MODIFIER
355	collapseMiddle = micros1.modMiddle->semanticallyEquivalent(*micros2.modMiddle);
356
357	if (!collapseMiddle) {
358	// Never collapse inner mods if outer mods are not collapsable
359	collapseInner = false;
360	break;
361	}
362
363	// MIDDLE MODIFIER HEURISTICS
364	// (could disable collapsing of the middle modifier)
365	// The modifiers are equal by this point, so we can look at just one of them.
366	const Modifier* mm = micros1.modMiddle;
367	if (fCollapse == UNUM_RANGE_COLLAPSE_UNIT) {
368	// Only collapse if the modifier is a unit.
369	// TODO: Make a better way to check for a unit?
370	// TODO: Handle case where the modifier has both notation and unit (compact currency)?
371	if (!mm->containsField(UNUM_CURRENCY_FIELD) && !mm->containsField(UNUM_PERCENT_FIELD)) {
372	collapseMiddle = false;
373	}
374	} else if (fCollapse == UNUM_RANGE_COLLAPSE_AUTO) {
375	// Heuristic as of ICU 63: collapse only if the modifier is more than one code point.
376	if (mm->getCodePointCount() <= 1) {
377	collapseMiddle = false;
378	}
379	}
380
381	if (!collapseMiddle \|\| fCollapse != UNUM_RANGE_COLLAPSE_ALL) {
382	collapseInner = false;
383	break;
384	}
385
386	// INNER MODIFIER
387	collapseInner = micros1.modInner->semanticallyEquivalent(*micros2.modInner);
388
389	// All done checking for collapsability.
390	break;
391	}
392
393	default:
394	collapseOuter = false;
395	collapseMiddle = false;
396	collapseInner = false;
397	break;
398	}
399
400	NumberStringBuilder& string = data.getStringRef();
401	int32_t lengthPrefix = 0;
402	int32_t length1 = 0;
403	int32_t lengthInfix = 0;
404	int32_t length2 = 0;
405	int32_t lengthSuffix = 0;
406
407	// Use #define so that these are evaluated at the call site.
408	#define UPRV_INDEX_0 (lengthPrefix)
409	#define UPRV_INDEX_1 (lengthPrefix + length1)
410	#define UPRV_INDEX_2 (lengthPrefix + length1 + lengthInfix)
411	#define UPRV_INDEX_3 (lengthPrefix + length1 + lengthInfix + length2)
412
413	int32_t lengthRange = SimpleModifier::formatTwoArgPattern(
414	fRangeFormatter,
415	string,
416	0,
417	&lengthPrefix,
418	&lengthSuffix,
419	UNUM_FIELD_COUNT,
420	status);
421	if (U_FAILURE(status)) { return; }
422	lengthInfix = lengthRange - lengthPrefix - lengthSuffix;
423	U_ASSERT(lengthInfix > 0);
424
425	// SPACING HEURISTIC
426	// Add spacing unless all modifiers are collapsed.
427	// TODO: add API to control this?
428	// TODO: Use a data-driven heuristic like currency spacing?
429	// TODO: Use Unicode [:whitespace:] instead of PatternProps whitespace? (consider speed implications)
430	{
431	bool repeatInner = !collapseInner && micros1.modInner->getCodePointCount() > 0;
432	bool repeatMiddle = !collapseMiddle && micros1.modMiddle->getCodePointCount() > 0;
433	bool repeatOuter = !collapseOuter && micros1.modOuter->getCodePointCount() > 0;
434	if (repeatInner \|\| repeatMiddle \|\| repeatOuter) {
435	// Add spacing if there is not already spacing
436	if (!PatternProps::isWhiteSpace(string.charAt(UPRV_INDEX_1))) {
437	lengthInfix += string.insertCodePoint(UPRV_INDEX_1, u'\u0020', UNUM_FIELD_COUNT, status);
438	}
439	if (!PatternProps::isWhiteSpace(string.charAt(UPRV_INDEX_2 - 1))) {
440	lengthInfix += string.insertCodePoint(UPRV_INDEX_2, u'\u0020', UNUM_FIELD_COUNT, status);
441	}
442	}
443	}
444
445	length1 += NumberFormatterImpl::writeNumber(micros1, data.quantity1, string, UPRV_INDEX_0, status);
446	length2 += NumberFormatterImpl::writeNumber(micros2, data.quantity2, string, UPRV_INDEX_2, status);
447
448	// TODO: Support padding?
449
450	if (collapseInner) {
451	// Note: this is actually a mix of prefix and suffix, but adding to infix length works
452	const Modifier& mod = resolveModifierPlurals(micros1.modInner, micros2.modInner);
453	lengthInfix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_3, status);
454	} else {
455	length1 += micros1.modInner->apply(string, UPRV_INDEX_0, UPRV_INDEX_1, status);
456	length2 += micros2.modInner->apply(string, UPRV_INDEX_2, UPRV_INDEX_3, status);
457	}
458
459	if (collapseMiddle) {
460	// Note: this is actually a mix of prefix and suffix, but adding to infix length works
461	const Modifier& mod = resolveModifierPlurals(micros1.modMiddle, micros2.modMiddle);
462	lengthInfix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_3, status);
463	} else {
464	length1 += micros1.modMiddle->apply(string, UPRV_INDEX_0, UPRV_INDEX_1, status);
465	length2 += micros2.modMiddle->apply(string, UPRV_INDEX_2, UPRV_INDEX_3, status);
466	}
467
468	if (collapseOuter) {
469	// Note: this is actually a mix of prefix and suffix, but adding to infix length works
470	const Modifier& mod = resolveModifierPlurals(micros1.modOuter, micros2.modOuter);
471	lengthInfix += mod.apply(string, UPRV_INDEX_0, UPRV_INDEX_3, status);
472	} else {
473	length1 += micros1.modOuter->apply(string, UPRV_INDEX_0, UPRV_INDEX_1, status);
474	length2 += micros2.modOuter->apply(string, UPRV_INDEX_2, UPRV_INDEX_3, status);
475	}
476	}
477
478
479	const Modifier&
480	NumberRangeFormatterImpl::resolveModifierPlurals(const Modifier& first, const Modifier& second) const {
481	Modifier::Parameters parameters;
482	first.getParameters(parameters);
483	if (parameters.obj == nullptr) {
484	// No plural form; return a fallback (e.g., the first)
485	return first;
486	}
487	StandardPlural::Form firstPlural = parameters.plural;
488
489	second.getParameters(parameters);
490	if (parameters.obj == nullptr) {
491	// No plural form; return a fallback (e.g., the first)
492	return first;
493	}
494	StandardPlural::Form secondPlural = parameters.plural;
495
496	// Get the required plural form from data
497	StandardPlural::Form resultPlural = fPluralRanges.resolve(firstPlural, secondPlural);
498
499	// Get and return the new Modifier
500	const Modifier* mod = parameters.obj->getModifier(parameters.signum, resultPlural);
501	U_ASSERT(mod != nullptr);
502	return *mod;
503	}
504
505
506
507	#endif /* #if !UCONFIG_NO_FORMATTING */