[apple/icu.git] / icuSources / i18n / number_mapper.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 "number_mapper.h"
#include "number_patternstring.h"
#include "unicode/errorcode.h"
#include "number_utils.h"
#include "number_currencysymbols.h"

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


UnlocalizedNumberFormatter NumberPropertyMapper::create(const DecimalFormatProperties& properties,
                                                        const DecimalFormatSymbols& symbols,
                                                        DecimalFormatWarehouse& warehouse,
                                                        UErrorCode& status) {
    return NumberFormatter::with().macros(oldToNew(properties, symbols, warehouse, nullptr, status));
}

UnlocalizedNumberFormatter NumberPropertyMapper::create(const DecimalFormatProperties& properties,
                                                        const DecimalFormatSymbols& symbols,
                                                        DecimalFormatWarehouse& warehouse,
                                                        DecimalFormatProperties& exportedProperties,
                                                        UErrorCode& status) {
    return NumberFormatter::with().macros(
            oldToNew(
                    properties, symbols, warehouse, &exportedProperties, status));
}

MacroProps NumberPropertyMapper::oldToNew(const DecimalFormatProperties& properties,
                                          const DecimalFormatSymbols& symbols,
                                          DecimalFormatWarehouse& warehouse,
                                          DecimalFormatProperties* exportedProperties,
                                          UErrorCode& status) {
    MacroProps macros;
    Locale locale = symbols.getLocale();

    /////////////
    // SYMBOLS //
    /////////////

    macros.symbols.setTo(symbols);

    //////////////////
    // PLURAL RULES //
    //////////////////

    if (!properties.currencyPluralInfo.fPtr.isNull()) {
        macros.rules = properties.currencyPluralInfo.fPtr->getPluralRules();
    }

    /////////////
    // AFFIXES //
    /////////////

    AffixPatternProvider* affixProvider;
    if (properties.currencyPluralInfo.fPtr.isNull()) {
        warehouse.currencyPluralInfoAPP.setToBogus();
        warehouse.propertiesAPP.setTo(properties, status);
        affixProvider = &warehouse.propertiesAPP;
    } else {
        warehouse.currencyPluralInfoAPP.setTo(*properties.currencyPluralInfo.fPtr, properties, status);
        warehouse.propertiesAPP.setToBogus();
        affixProvider = &warehouse.currencyPluralInfoAPP;
    }
    macros.affixProvider = affixProvider;

    ///////////
    // UNITS //
    ///////////

    bool useCurrency = (
            !properties.currency.isNull() || !properties.currencyPluralInfo.fPtr.isNull() ||
            !properties.currencyUsage.isNull() || affixProvider->hasCurrencySign());
    CurrencyUnit currency = resolveCurrency(properties, locale, status);
    UCurrencyUsage currencyUsage = properties.currencyUsage.getOrDefault(UCURR_USAGE_STANDARD);
    if (useCurrency) {
        // NOTE: Slicing is OK.
        macros.unit = currency; // NOLINT
    }
    warehouse.currencySymbols = {currency, locale, symbols, status};
    macros.currencySymbols = &warehouse.currencySymbols;

    ///////////////////////
    // ROUNDING STRATEGY //
    ///////////////////////

    int32_t maxInt = properties.maximumIntegerDigits;
    int32_t minInt = properties.minimumIntegerDigits;
    int32_t maxFrac = properties.maximumFractionDigits;
    int32_t minFrac = properties.minimumFractionDigits;
    int32_t minSig = properties.minimumSignificantDigits;
    int32_t maxSig = properties.maximumSignificantDigits;
    double roundingIncrement = properties.roundingIncrement;
    RoundingMode roundingMode = properties.roundingMode.getOrDefault(UNUM_ROUND_HALFEVEN);
    bool explicitMinMaxFrac = minFrac != -1 || maxFrac != -1;
    bool explicitMinMaxSig = minSig != -1 || maxSig != -1;
    // Resolve min/max frac for currencies, required for the validation logic and for when minFrac or
    // maxFrac was
    // set (but not both) on a currency instance.
    // NOTE: Increments are handled in "Precision.constructCurrency()".
    if (useCurrency && (minFrac == -1 || maxFrac == -1)) {
        int32_t digits = ucurr_getDefaultFractionDigitsForUsage(
                currency.getISOCurrency(), currencyUsage, &status);
        if (minFrac == -1 && maxFrac == -1) {
            minFrac = digits;
            maxFrac = digits;
        } else if (minFrac == -1) {
            minFrac = std::min(maxFrac, digits);
        } else /* if (maxFrac == -1) */ {
            maxFrac = std::max(minFrac, digits);
        }
    }
    // Validate min/max int/frac.
    // For backwards compatibility, minimum overrides maximum if the two conflict.
    // The following logic ensures that there is always a minimum of at least one digit.
    if (minInt == 0 && maxFrac != 0) {
        // Force a digit after the decimal point.
        minFrac = minFrac <= 0 ? 1 : minFrac;
        maxFrac = maxFrac < 0 ? -1 : maxFrac < minFrac ? minFrac : maxFrac;
        minInt = 0;
        maxInt = maxInt < 0 ? -1 : maxInt > kMaxIntFracSig ? -1 : maxInt;
    } else {
        // Force a digit before the decimal point.
        minFrac = minFrac < 0 ? 0 : minFrac;
        maxFrac = maxFrac < 0 ? -1 : maxFrac < minFrac ? minFrac : maxFrac;
        minInt = minInt <= 0 ? 1 : minInt > kMaxIntFracSig ? 1 : minInt;
        maxInt = maxInt < 0 ? -1 : maxInt < minInt ? minInt : maxInt > kMaxIntFracSig ? -1 : maxInt;
    }
    Precision precision;
    if (!properties.currencyUsage.isNull()) {
        precision = Precision::constructCurrency(currencyUsage).withCurrency(currency);
    } else if (roundingIncrement != 0.0) {
        precision = Precision::constructIncrement(roundingIncrement, minFrac);
    } else if (explicitMinMaxSig) {
        minSig = minSig < 1 ? 1 : minSig > kMaxIntFracSig ? kMaxIntFracSig : minSig;
        maxSig = maxSig < 0 ? kMaxIntFracSig : maxSig < minSig ? minSig : maxSig > kMaxIntFracSig
                                                                          ? kMaxIntFracSig : maxSig;
        precision = Precision::constructSignificant(minSig, maxSig);
    } else if (explicitMinMaxFrac) {
        precision = Precision::constructFraction(minFrac, maxFrac);
    } else if (useCurrency) {
        precision = Precision::constructCurrency(currencyUsage);
    }
    if (!precision.isBogus()) {
        precision = precision.withMode(roundingMode);
        macros.precision = precision;
    }

    ///////////////////
    // INTEGER WIDTH //
    ///////////////////

    macros.integerWidth = IntegerWidth(
            static_cast<digits_t>(minInt),
            static_cast<digits_t>(maxInt),
            properties.formatFailIfMoreThanMaxDigits);

    ///////////////////////
    // GROUPING STRATEGY //
    ///////////////////////

    macros.grouper = Grouper::forProperties(properties);

    /////////////
    // PADDING //
    /////////////

    if (properties.formatWidth != -1) {
        macros.padder = Padder::forProperties(properties);
    }

    ///////////////////////////////
    // DECIMAL MARK ALWAYS SHOWN //
    ///////////////////////////////

    macros.decimal = properties.decimalSeparatorAlwaysShown ? UNUM_DECIMAL_SEPARATOR_ALWAYS
                                                            : UNUM_DECIMAL_SEPARATOR_AUTO;

    ///////////////////////
    // SIGN ALWAYS SHOWN //
    ///////////////////////

    macros.sign = properties.signAlwaysShown ? UNUM_SIGN_ALWAYS : UNUM_SIGN_AUTO;

    /////////////////////////
    // SCIENTIFIC NOTATION //
    /////////////////////////

    if (properties.minimumExponentDigits != -1) {
        // Scientific notation is required.
        // This whole section feels like a hack, but it is needed for regression tests.
        // The mapping from property bag to scientific notation is nontrivial due to LDML rules.
        if (maxInt > 8) {
            // But #13110: The maximum of 8 digits has unknown origins and is not in the spec.
            // If maxInt is greater than 8, it is set to minInt, even if minInt is greater than 8.
            maxInt = minInt;
            macros.integerWidth = IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt);
        } else if (maxInt > minInt && minInt > 1) {
            // Bug #13289: if maxInt > minInt > 1, then minInt should be 1.
            minInt = 1;
            macros.integerWidth = IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt);
        }
        int engineering = maxInt < 0 ? -1 : maxInt;
        macros.notation = ScientificNotation(
                // Engineering interval:
                static_cast<int8_t>(engineering),
                // Enforce minimum integer digits (for patterns like "000.00E0"):
                (engineering == minInt),
                // Minimum exponent digits:
                static_cast<digits_t>(properties.minimumExponentDigits),
                // Exponent sign always shown:
                properties.exponentSignAlwaysShown ? UNUM_SIGN_ALWAYS : UNUM_SIGN_AUTO);
        // Scientific notation also involves overriding the rounding mode.
        // TODO: Overriding here is a bit of a hack. Should this logic go earlier?
        if (macros.precision.fType == Precision::PrecisionType::RND_FRACTION) {
            // For the purposes of rounding, get the original min/max int/frac, since the local
            // variables
            // have been manipulated for display purposes.
            int minInt_ = properties.minimumIntegerDigits;
            int minFrac_ = properties.minimumFractionDigits;
            int maxFrac_ = properties.maximumFractionDigits;
            if (minInt_ == 0 && maxFrac_ == 0) {
                // Patterns like "#E0" and "##E0", which mean no rounding!
                macros.precision = Precision::unlimited().withMode(roundingMode);
            } else if (minInt_ == 0 && minFrac_ == 0) {
                // Patterns like "#.##E0" (no zeros in the mantissa), which mean round to maxFrac+1
                macros.precision = Precision::constructSignificant(1, maxFrac_ + 1).withMode(roundingMode);
            } else {
                // All other scientific patterns, which mean round to minInt+maxFrac
                macros.precision = Precision::constructSignificant(
                        minInt_ + minFrac_, minInt_ + maxFrac_).withMode(roundingMode);
            }
        }
    }

    //////////////////////
    // COMPACT NOTATION //
    //////////////////////

    if (!properties.compactStyle.isNull()) {
        if (properties.compactStyle.getNoError() == UNumberCompactStyle::UNUM_LONG) {
            macros.notation = Notation::compactLong();
        } else {
            macros.notation = Notation::compactShort();
        }
        // Do not forward the affix provider.
        macros.affixProvider = nullptr;
    }

    /////////////////
    // MULTIPLIERS //
    /////////////////

    macros.scale = scaleFromProperties(properties);

    //////////////////////
    // PROPERTY EXPORTS //
    //////////////////////

    if (exportedProperties != nullptr) {

        exportedProperties->currency = currency;
        exportedProperties->roundingMode = roundingMode;
        exportedProperties->minimumIntegerDigits = minInt;
        exportedProperties->maximumIntegerDigits = maxInt == -1 ? INT32_MAX : maxInt;

        Precision rounding_;
        if (precision.fType == Precision::PrecisionType::RND_CURRENCY) {
            rounding_ = precision.withCurrency(currency, status);
        } else {
            rounding_ = precision;
        }
        int minFrac_ = minFrac;
        int maxFrac_ = maxFrac;
        int minSig_ = minSig;
        int maxSig_ = maxSig;
        double increment_ = 0.0;
        if (rounding_.fType == Precision::PrecisionType::RND_FRACTION) {
            minFrac_ = rounding_.fUnion.fracSig.fMinFrac;
            maxFrac_ = rounding_.fUnion.fracSig.fMaxFrac;
        } else if (rounding_.fType == Precision::PrecisionType::RND_INCREMENT) {
            increment_ = rounding_.fUnion.increment.fIncrement;
            minFrac_ = rounding_.fUnion.increment.fMinFrac;
            maxFrac_ = rounding_.fUnion.increment.fMinFrac;
        } else if (rounding_.fType == Precision::PrecisionType::RND_SIGNIFICANT) {
            minSig_ = rounding_.fUnion.fracSig.fMinSig;
            maxSig_ = rounding_.fUnion.fracSig.fMaxSig;
        }

        exportedProperties->minimumFractionDigits = minFrac_;
        exportedProperties->maximumFractionDigits = maxFrac_;
        exportedProperties->minimumSignificantDigits = minSig_;
        exportedProperties->maximumSignificantDigits = maxSig_;
        exportedProperties->roundingIncrement = increment_;
    }

    return macros;
}


void PropertiesAffixPatternProvider::setTo(const DecimalFormatProperties& properties, UErrorCode&) {
    fBogus = false;

    // There are two ways to set affixes in DecimalFormat: via the pattern string (applyPattern), and via the
    // explicit setters (setPositivePrefix and friends).  The way to resolve the settings is as follows:
    //
    // 1) If the explicit setting is present for the field, use it.
    // 2) Otherwise, follows UTS 35 rules based on the pattern string.
    //
    // Importantly, the explicit setters affect only the one field they override.  If you set the positive
    // prefix, that should not affect the negative prefix.  Since it is impossible for the user of this class
    // to know whether the origin for a string was the override or the pattern, we have to say that we always
    // have a negative subpattern and perform all resolution logic here.

    // Convenience: Extract the properties into local variables.
    // Variables are named with three chars: [p/n][p/s][o/p]
    // [p/n] => p for positive, n for negative
    // [p/s] => p for prefix, s for suffix
    // [o/p] => o for escaped custom override string, p for pattern string
    UnicodeString ppo = AffixUtils::escape(properties.positivePrefix);
    UnicodeString pso = AffixUtils::escape(properties.positiveSuffix);
    UnicodeString npo = AffixUtils::escape(properties.negativePrefix);
    UnicodeString nso = AffixUtils::escape(properties.negativeSuffix);
    const UnicodeString& ppp = properties.positivePrefixPattern;
    const UnicodeString& psp = properties.positiveSuffixPattern;
    const UnicodeString& npp = properties.negativePrefixPattern;
    const UnicodeString& nsp = properties.negativeSuffixPattern;

    if (!properties.positivePrefix.isBogus()) {
        posPrefix = ppo;
    } else if (!ppp.isBogus()) {
        posPrefix = ppp;
    } else {
        // UTS 35: Default positive prefix is empty string.
        posPrefix = u"";
    }

    if (!properties.positiveSuffix.isBogus()) {
        posSuffix = pso;
    } else if (!psp.isBogus()) {
        posSuffix = psp;
    } else {
        // UTS 35: Default positive suffix is empty string.
        posSuffix = u"";
    }

    if (!properties.negativePrefix.isBogus()) {
        negPrefix = npo;
    } else if (!npp.isBogus()) {
        negPrefix = npp;
    } else {
        // UTS 35: Default negative prefix is "-" with positive prefix.
        // Important: We prepend the "-" to the pattern, not the override!
        negPrefix = ppp.isBogus() ? u"-" : u"-" + ppp;
    }

    if (!properties.negativeSuffix.isBogus()) {
        negSuffix = nso;
    } else if (!nsp.isBogus()) {
        negSuffix = nsp;
    } else {
        // UTS 35: Default negative prefix is the positive prefix.
        negSuffix = psp.isBogus() ? u"" : psp;
    }
}

char16_t PropertiesAffixPatternProvider::charAt(int flags, int i) const {
    return getStringInternal(flags).charAt(i);
}

int PropertiesAffixPatternProvider::length(int flags) const {
    return getStringInternal(flags).length();
}

UnicodeString PropertiesAffixPatternProvider::getString(int32_t flags) const {
    return getStringInternal(flags);
}

const UnicodeString& PropertiesAffixPatternProvider::getStringInternal(int32_t flags) const {
    bool prefix = (flags & AFFIX_PREFIX) != 0;
    bool negative = (flags & AFFIX_NEGATIVE_SUBPATTERN) != 0;
    if (prefix && negative) {
        return negPrefix;
    } else if (prefix) {
        return posPrefix;
    } else if (negative) {
        return negSuffix;
    } else {
        return posSuffix;
    }
}

bool PropertiesAffixPatternProvider::positiveHasPlusSign() const {
    // TODO: Change the internal APIs to propagate out the error?
    ErrorCode localStatus;
    return AffixUtils::containsType(posPrefix, TYPE_PLUS_SIGN, localStatus) ||
           AffixUtils::containsType(posSuffix, TYPE_PLUS_SIGN, localStatus);
}

bool PropertiesAffixPatternProvider::hasNegativeSubpattern() const {
    // See comments in the constructor for more information on why this is always true.
    return true;
}

bool PropertiesAffixPatternProvider::negativeHasMinusSign() const {
    ErrorCode localStatus;
    return AffixUtils::containsType(negPrefix, TYPE_MINUS_SIGN, localStatus) ||
           AffixUtils::containsType(negSuffix, TYPE_MINUS_SIGN, localStatus);
}

bool PropertiesAffixPatternProvider::hasCurrencySign() const {
    ErrorCode localStatus;
    return AffixUtils::hasCurrencySymbols(posPrefix, localStatus) ||
           AffixUtils::hasCurrencySymbols(posSuffix, localStatus) ||
           AffixUtils::hasCurrencySymbols(negPrefix, localStatus) ||
           AffixUtils::hasCurrencySymbols(negSuffix, localStatus);
}

bool PropertiesAffixPatternProvider::containsSymbolType(AffixPatternType type, UErrorCode& status) const {
    return AffixUtils::containsType(posPrefix, type, status) ||
           AffixUtils::containsType(posSuffix, type, status) ||
           AffixUtils::containsType(negPrefix, type, status) ||
           AffixUtils::containsType(negSuffix, type, status);
}

bool PropertiesAffixPatternProvider::hasBody() const {
    return true;
}


void CurrencyPluralInfoAffixProvider::setTo(const CurrencyPluralInfo& cpi,
                                            const DecimalFormatProperties& properties,
                                            UErrorCode& status) {
    // We need to use a PropertiesAffixPatternProvider, not the simpler version ParsedPatternInfo,
    // because user-specified affix overrides still need to work.
    fBogus = false;
    DecimalFormatProperties pluralProperties(properties);
    for (int32_t plural = 0; plural < StandardPlural::COUNT; plural++) {
        const char* keyword = StandardPlural::getKeyword(static_cast<StandardPlural::Form>(plural));
        UnicodeString patternString;
        patternString = cpi.getCurrencyPluralPattern(keyword, patternString);
        PatternParser::parseToExistingProperties(
                patternString,
                pluralProperties,
                IGNORE_ROUNDING_NEVER,
                status);
        affixesByPlural[plural].setTo(pluralProperties, status);
    }
}

char16_t CurrencyPluralInfoAffixProvider::charAt(int32_t flags, int32_t i) const {
    int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);
    return affixesByPlural[pluralOrdinal].charAt(flags, i);
}

int32_t CurrencyPluralInfoAffixProvider::length(int32_t flags) const {
    int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);
    return affixesByPlural[pluralOrdinal].length(flags);
}

UnicodeString CurrencyPluralInfoAffixProvider::getString(int32_t flags) const {
    int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);
    return affixesByPlural[pluralOrdinal].getString(flags);
}

bool CurrencyPluralInfoAffixProvider::positiveHasPlusSign() const {
    return affixesByPlural[StandardPlural::OTHER].positiveHasPlusSign();
}

bool CurrencyPluralInfoAffixProvider::hasNegativeSubpattern() const {
    return affixesByPlural[StandardPlural::OTHER].hasNegativeSubpattern();
}

bool CurrencyPluralInfoAffixProvider::negativeHasMinusSign() const {
    return affixesByPlural[StandardPlural::OTHER].negativeHasMinusSign();
}

bool CurrencyPluralInfoAffixProvider::hasCurrencySign() const {
    return affixesByPlural[StandardPlural::OTHER].hasCurrencySign();
}

bool CurrencyPluralInfoAffixProvider::containsSymbolType(AffixPatternType type, UErrorCode& status) const {
    return affixesByPlural[StandardPlural::OTHER].containsSymbolType(type, status);
}

bool CurrencyPluralInfoAffixProvider::hasBody() const {
    return affixesByPlural[StandardPlural::OTHER].hasBody();
}


#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
0f5d89e8 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 "number_mapper.h"
	13	#include "number_patternstring.h"
	14	#include "unicode/errorcode.h"
	15	#include "number_utils.h"
	16	#include "number_currencysymbols.h"
	17
	18	using namespace icu;
	19	using namespace icu::number;
	20	using namespace icu::number::impl;
	21
	22
	23	UnlocalizedNumberFormatter NumberPropertyMapper::create(const DecimalFormatProperties& properties,
	24	const DecimalFormatSymbols& symbols,
	25	DecimalFormatWarehouse& warehouse,
	26	UErrorCode& status) {
	27	return NumberFormatter::with().macros(oldToNew(properties, symbols, warehouse, nullptr, status));
	28	}
	29
	30	UnlocalizedNumberFormatter NumberPropertyMapper::create(const DecimalFormatProperties& properties,
	31	const DecimalFormatSymbols& symbols,
	32	DecimalFormatWarehouse& warehouse,
	33	DecimalFormatProperties& exportedProperties,
	34	UErrorCode& status) {
	35	return NumberFormatter::with().macros(
	36	oldToNew(
	37	properties, symbols, warehouse, &exportedProperties, status));
	38	}
	39
	40	MacroProps NumberPropertyMapper::oldToNew(const DecimalFormatProperties& properties,
	41	const DecimalFormatSymbols& symbols,
	42	DecimalFormatWarehouse& warehouse,
	43	DecimalFormatProperties* exportedProperties,
	44	UErrorCode& status) {
	45	MacroProps macros;
	46	Locale locale = symbols.getLocale();
	47
	48	/////////////
	49	// SYMBOLS //
	50	/////////////
	51
	52	macros.symbols.setTo(symbols);
	53
	54	//////////////////
	55	// PLURAL RULES //
	56	//////////////////
	57
	58	if (!properties.currencyPluralInfo.fPtr.isNull()) {
	59	macros.rules = properties.currencyPluralInfo.fPtr->getPluralRules();
	60	}
	61
	62	/////////////
	63	// AFFIXES //
	64	/////////////
65
66	AffixPatternProvider* affixProvider;
67	if (properties.currencyPluralInfo.fPtr.isNull()) {
68	warehouse.currencyPluralInfoAPP.setToBogus();
69	warehouse.propertiesAPP.setTo(properties, status);
70	affixProvider = &warehouse.propertiesAPP;
71	} else {
72	warehouse.currencyPluralInfoAPP.setTo(*properties.currencyPluralInfo.fPtr, properties, status);
73	warehouse.propertiesAPP.setToBogus();
74	affixProvider = &warehouse.currencyPluralInfoAPP;
75	}
76	macros.affixProvider = affixProvider;
77
78	///////////
79	// UNITS //
80	///////////
81
82	bool useCurrency = (
83	!properties.currency.isNull() \|\| !properties.currencyPluralInfo.fPtr.isNull() \|\|
84	!properties.currencyUsage.isNull() \|\| affixProvider->hasCurrencySign());
85	CurrencyUnit currency = resolveCurrency(properties, locale, status);
86	UCurrencyUsage currencyUsage = properties.currencyUsage.getOrDefault(UCURR_USAGE_STANDARD);
87	if (useCurrency) {
88	// NOTE: Slicing is OK.
89	macros.unit = currency; // NOLINT
90	}
91	warehouse.currencySymbols = {currency, locale, symbols, status};
92	macros.currencySymbols = &warehouse.currencySymbols;
93
94	///////////////////////
95	// ROUNDING STRATEGY //
96	///////////////////////
97
98	int32_t maxInt = properties.maximumIntegerDigits;
99	int32_t minInt = properties.minimumIntegerDigits;
100	int32_t maxFrac = properties.maximumFractionDigits;
101	int32_t minFrac = properties.minimumFractionDigits;
102	int32_t minSig = properties.minimumSignificantDigits;
103	int32_t maxSig = properties.maximumSignificantDigits;
104	double roundingIncrement = properties.roundingIncrement;
105	RoundingMode roundingMode = properties.roundingMode.getOrDefault(UNUM_ROUND_HALFEVEN);
106	bool explicitMinMaxFrac = minFrac != -1 \|\| maxFrac != -1;
107	bool explicitMinMaxSig = minSig != -1 \|\| maxSig != -1;
108	// Resolve min/max frac for currencies, required for the validation logic and for when minFrac or
109	// maxFrac was
110	// set (but not both) on a currency instance.
111	// NOTE: Increments are handled in "Precision.constructCurrency()".
112	if (useCurrency && (minFrac == -1 \|\| maxFrac == -1)) {
113	int32_t digits = ucurr_getDefaultFractionDigitsForUsage(
114	currency.getISOCurrency(), currencyUsage, &status);
115	if (minFrac == -1 && maxFrac == -1) {
116	minFrac = digits;
117	maxFrac = digits;
118	} else if (minFrac == -1) {
119	minFrac = std::min(maxFrac, digits);
120	} else /* if (maxFrac == -1) */ {
121	maxFrac = std::max(minFrac, digits);
122	}
123	}
124	// Validate min/max int/frac.
125	// For backwards compatibility, minimum overrides maximum if the two conflict.
126	// The following logic ensures that there is always a minimum of at least one digit.
127	if (minInt == 0 && maxFrac != 0) {
128	// Force a digit after the decimal point.
129	minFrac = minFrac <= 0 ? 1 : minFrac;
130	maxFrac = maxFrac < 0 ? -1 : maxFrac < minFrac ? minFrac : maxFrac;
131	minInt = 0;
132	maxInt = maxInt < 0 ? -1 : maxInt > kMaxIntFracSig ? -1 : maxInt;
133	} else {
134	// Force a digit before the decimal point.
135	minFrac = minFrac < 0 ? 0 : minFrac;
136	maxFrac = maxFrac < 0 ? -1 : maxFrac < minFrac ? minFrac : maxFrac;
137	minInt = minInt <= 0 ? 1 : minInt > kMaxIntFracSig ? 1 : minInt;
138	maxInt = maxInt < 0 ? -1 : maxInt < minInt ? minInt : maxInt > kMaxIntFracSig ? -1 : maxInt;
139	}
140	Precision precision;
141	if (!properties.currencyUsage.isNull()) {
142	precision = Precision::constructCurrency(currencyUsage).withCurrency(currency);
143	} else if (roundingIncrement != 0.0) {
144	precision = Precision::constructIncrement(roundingIncrement, minFrac);
145	} else if (explicitMinMaxSig) {
146	minSig = minSig < 1 ? 1 : minSig > kMaxIntFracSig ? kMaxIntFracSig : minSig;
147	maxSig = maxSig < 0 ? kMaxIntFracSig : maxSig < minSig ? minSig : maxSig > kMaxIntFracSig
148	? kMaxIntFracSig : maxSig;
149	precision = Precision::constructSignificant(minSig, maxSig);
150	} else if (explicitMinMaxFrac) {
151	precision = Precision::constructFraction(minFrac, maxFrac);
152	} else if (useCurrency) {
153	precision = Precision::constructCurrency(currencyUsage);
154	}
155	if (!precision.isBogus()) {
156	precision = precision.withMode(roundingMode);
157	macros.precision = precision;
158	}
159
160	///////////////////
161	// INTEGER WIDTH //
162	///////////////////
163
164	macros.integerWidth = IntegerWidth(
165	static_cast<digits_t>(minInt),
166	static_cast<digits_t>(maxInt),
167	properties.formatFailIfMoreThanMaxDigits);
168
169	///////////////////////
170	// GROUPING STRATEGY //
171	///////////////////////
172
173	macros.grouper = Grouper::forProperties(properties);
174
175	/////////////
176	// PADDING //
177	/////////////
178
179	if (properties.formatWidth != -1) {
180	macros.padder = Padder::forProperties(properties);
181	}
182
183	///////////////////////////////
184	// DECIMAL MARK ALWAYS SHOWN //
185	///////////////////////////////
186
187	macros.decimal = properties.decimalSeparatorAlwaysShown ? UNUM_DECIMAL_SEPARATOR_ALWAYS
188	: UNUM_DECIMAL_SEPARATOR_AUTO;
189
190	///////////////////////
191	// SIGN ALWAYS SHOWN //
192	///////////////////////
193
194	macros.sign = properties.signAlwaysShown ? UNUM_SIGN_ALWAYS : UNUM_SIGN_AUTO;
195
196	/////////////////////////
197	// SCIENTIFIC NOTATION //
198	/////////////////////////
199
200	if (properties.minimumExponentDigits != -1) {
201	// Scientific notation is required.
202	// This whole section feels like a hack, but it is needed for regression tests.
203	// The mapping from property bag to scientific notation is nontrivial due to LDML rules.
204	if (maxInt > 8) {
205	// But #13110: The maximum of 8 digits has unknown origins and is not in the spec.
206	// If maxInt is greater than 8, it is set to minInt, even if minInt is greater than 8.
207	maxInt = minInt;
208	macros.integerWidth = IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt);
209	} else if (maxInt > minInt && minInt > 1) {
210	// Bug #13289: if maxInt > minInt > 1, then minInt should be 1.
211	minInt = 1;
212	macros.integerWidth = IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt);
213	}
214	int engineering = maxInt < 0 ? -1 : maxInt;
215	macros.notation = ScientificNotation(
216	// Engineering interval:
217	static_cast<int8_t>(engineering),
218	// Enforce minimum integer digits (for patterns like "000.00E0"):
219	(engineering == minInt),
220	// Minimum exponent digits:
221	static_cast<digits_t>(properties.minimumExponentDigits),
222	// Exponent sign always shown:
223	properties.exponentSignAlwaysShown ? UNUM_SIGN_ALWAYS : UNUM_SIGN_AUTO);
224	// Scientific notation also involves overriding the rounding mode.
225	// TODO: Overriding here is a bit of a hack. Should this logic go earlier?
226	if (macros.precision.fType == Precision::PrecisionType::RND_FRACTION) {
227	// For the purposes of rounding, get the original min/max int/frac, since the local
228	// variables
229	// have been manipulated for display purposes.
230	int minInt_ = properties.minimumIntegerDigits;
231	int minFrac_ = properties.minimumFractionDigits;
232	int maxFrac_ = properties.maximumFractionDigits;
233	if (minInt_ == 0 && maxFrac_ == 0) {
234	// Patterns like "#E0" and "##E0", which mean no rounding!
235	macros.precision = Precision::unlimited().withMode(roundingMode);
236	} else if (minInt_ == 0 && minFrac_ == 0) {
237	// Patterns like "#.##E0" (no zeros in the mantissa), which mean round to maxFrac+1
238	macros.precision = Precision::constructSignificant(1, maxFrac_ + 1).withMode(roundingMode);
239	} else {
240	// All other scientific patterns, which mean round to minInt+maxFrac
241	macros.precision = Precision::constructSignificant(
242	minInt_ + minFrac_, minInt_ + maxFrac_).withMode(roundingMode);
243	}
244	}
245	}
246
247	//////////////////////
248	// COMPACT NOTATION //
249	//////////////////////
250
251	if (!properties.compactStyle.isNull()) {
252	if (properties.compactStyle.getNoError() == UNumberCompactStyle::UNUM_LONG) {
253	macros.notation = Notation::compactLong();
254	} else {
255	macros.notation = Notation::compactShort();
256	}
257	// Do not forward the affix provider.
258	macros.affixProvider = nullptr;
259	}
260
261	/////////////////
262	// MULTIPLIERS //
263	/////////////////
264
265	macros.scale = scaleFromProperties(properties);
266
267	//////////////////////
268	// PROPERTY EXPORTS //
269	//////////////////////
270
271	if (exportedProperties != nullptr) {
272
273	exportedProperties->currency = currency;
274	exportedProperties->roundingMode = roundingMode;
275	exportedProperties->minimumIntegerDigits = minInt;
276	exportedProperties->maximumIntegerDigits = maxInt == -1 ? INT32_MAX : maxInt;
277
278	Precision rounding_;
279	if (precision.fType == Precision::PrecisionType::RND_CURRENCY) {
280	rounding_ = precision.withCurrency(currency, status);
281	} else {
282	rounding_ = precision;
283	}
284	int minFrac_ = minFrac;
285	int maxFrac_ = maxFrac;
286	int minSig_ = minSig;
287	int maxSig_ = maxSig;
288	double increment_ = 0.0;
289	if (rounding_.fType == Precision::PrecisionType::RND_FRACTION) {
290	minFrac_ = rounding_.fUnion.fracSig.fMinFrac;
291	maxFrac_ = rounding_.fUnion.fracSig.fMaxFrac;
292	} else if (rounding_.fType == Precision::PrecisionType::RND_INCREMENT) {
293	increment_ = rounding_.fUnion.increment.fIncrement;
294	minFrac_ = rounding_.fUnion.increment.fMinFrac;
295	maxFrac_ = rounding_.fUnion.increment.fMinFrac;
296	} else if (rounding_.fType == Precision::PrecisionType::RND_SIGNIFICANT) {
297	minSig_ = rounding_.fUnion.fracSig.fMinSig;
298	maxSig_ = rounding_.fUnion.fracSig.fMaxSig;
299	}
300
301	exportedProperties->minimumFractionDigits = minFrac_;
302	exportedProperties->maximumFractionDigits = maxFrac_;
303	exportedProperties->minimumSignificantDigits = minSig_;
304	exportedProperties->maximumSignificantDigits = maxSig_;
305	exportedProperties->roundingIncrement = increment_;
306	}
307
308	return macros;
309	}
310
311
312	void PropertiesAffixPatternProvider::setTo(const DecimalFormatProperties& properties, UErrorCode&) {
313	fBogus = false;
314
315	// There are two ways to set affixes in DecimalFormat: via the pattern string (applyPattern), and via the
316	// explicit setters (setPositivePrefix and friends). The way to resolve the settings is as follows:
317	//
318	// 1) If the explicit setting is present for the field, use it.
319	// 2) Otherwise, follows UTS 35 rules based on the pattern string.
320	//
321	// Importantly, the explicit setters affect only the one field they override. If you set the positive
322	// prefix, that should not affect the negative prefix. Since it is impossible for the user of this class
323	// to know whether the origin for a string was the override or the pattern, we have to say that we always
324	// have a negative subpattern and perform all resolution logic here.
325
326	// Convenience: Extract the properties into local variables.
327	// Variables are named with three chars: [p/n][p/s][o/p]
328	// [p/n] => p for positive, n for negative
329	// [p/s] => p for prefix, s for suffix
330	// [o/p] => o for escaped custom override string, p for pattern string
331	UnicodeString ppo = AffixUtils::escape(properties.positivePrefix);
332	UnicodeString pso = AffixUtils::escape(properties.positiveSuffix);
333	UnicodeString npo = AffixUtils::escape(properties.negativePrefix);
334	UnicodeString nso = AffixUtils::escape(properties.negativeSuffix);
335	const UnicodeString& ppp = properties.positivePrefixPattern;
336	const UnicodeString& psp = properties.positiveSuffixPattern;
337	const UnicodeString& npp = properties.negativePrefixPattern;
338	const UnicodeString& nsp = properties.negativeSuffixPattern;
339
340	if (!properties.positivePrefix.isBogus()) {
341	posPrefix = ppo;
342	} else if (!ppp.isBogus()) {
343	posPrefix = ppp;
344	} else {
345	// UTS 35: Default positive prefix is empty string.
346	posPrefix = u"";
347	}
348
349	if (!properties.positiveSuffix.isBogus()) {
350	posSuffix = pso;
351	} else if (!psp.isBogus()) {
352	posSuffix = psp;
353	} else {
354	// UTS 35: Default positive suffix is empty string.
355	posSuffix = u"";
356	}
357
358	if (!properties.negativePrefix.isBogus()) {
359	negPrefix = npo;
360	} else if (!npp.isBogus()) {
361	negPrefix = npp;
362	} else {
363	// UTS 35: Default negative prefix is "-" with positive prefix.
364	// Important: We prepend the "-" to the pattern, not the override!
365	negPrefix = ppp.isBogus() ? u"-" : u"-" + ppp;
366	}
367
368	if (!properties.negativeSuffix.isBogus()) {
369	negSuffix = nso;
370	} else if (!nsp.isBogus()) {
371	negSuffix = nsp;
372	} else {
373	// UTS 35: Default negative prefix is the positive prefix.
374	negSuffix = psp.isBogus() ? u"" : psp;
375	}
376	}
377
378	char16_t PropertiesAffixPatternProvider::charAt(int flags, int i) const {
379	return getStringInternal(flags).charAt(i);
380	}
381
382	int PropertiesAffixPatternProvider::length(int flags) const {
383	return getStringInternal(flags).length();
384	}
385
386	UnicodeString PropertiesAffixPatternProvider::getString(int32_t flags) const {
387	return getStringInternal(flags);
388	}
389
390	const UnicodeString& PropertiesAffixPatternProvider::getStringInternal(int32_t flags) const {
391	bool prefix = (flags & AFFIX_PREFIX) != 0;
392	bool negative = (flags & AFFIX_NEGATIVE_SUBPATTERN) != 0;
393	if (prefix && negative) {
394	return negPrefix;
395	} else if (prefix) {
396	return posPrefix;
397	} else if (negative) {
398	return negSuffix;
399	} else {
400	return posSuffix;
401	}
402	}
403
404	bool PropertiesAffixPatternProvider::positiveHasPlusSign() const {
405	// TODO: Change the internal APIs to propagate out the error?
406	ErrorCode localStatus;
407	return AffixUtils::containsType(posPrefix, TYPE_PLUS_SIGN, localStatus) \|\|
408	AffixUtils::containsType(posSuffix, TYPE_PLUS_SIGN, localStatus);
409	}
410
411	bool PropertiesAffixPatternProvider::hasNegativeSubpattern() const {
412	// See comments in the constructor for more information on why this is always true.
413	return true;
414	}
415
416	bool PropertiesAffixPatternProvider::negativeHasMinusSign() const {
417	ErrorCode localStatus;
418	return AffixUtils::containsType(negPrefix, TYPE_MINUS_SIGN, localStatus) \|\|
419	AffixUtils::containsType(negSuffix, TYPE_MINUS_SIGN, localStatus);
420	}
421
422	bool PropertiesAffixPatternProvider::hasCurrencySign() const {
423	ErrorCode localStatus;
424	return AffixUtils::hasCurrencySymbols(posPrefix, localStatus) \|\|
425	AffixUtils::hasCurrencySymbols(posSuffix, localStatus) \|\|
426	AffixUtils::hasCurrencySymbols(negPrefix, localStatus) \|\|
427	AffixUtils::hasCurrencySymbols(negSuffix, localStatus);
428	}
429
430	bool PropertiesAffixPatternProvider::containsSymbolType(AffixPatternType type, UErrorCode& status) const {
431	return AffixUtils::containsType(posPrefix, type, status) \|\|
432	AffixUtils::containsType(posSuffix, type, status) \|\|
433	AffixUtils::containsType(negPrefix, type, status) \|\|
434	AffixUtils::containsType(negSuffix, type, status);
435	}
436
437	bool PropertiesAffixPatternProvider::hasBody() const {
438	return true;
439	}
440
441
442	void CurrencyPluralInfoAffixProvider::setTo(const CurrencyPluralInfo& cpi,
443	const DecimalFormatProperties& properties,
444	UErrorCode& status) {
445	// We need to use a PropertiesAffixPatternProvider, not the simpler version ParsedPatternInfo,
446	// because user-specified affix overrides still need to work.
447	fBogus = false;
448	DecimalFormatProperties pluralProperties(properties);
449	for (int32_t plural = 0; plural < StandardPlural::COUNT; plural++) {
450	const char* keyword = StandardPlural::getKeyword(static_cast<StandardPlural::Form>(plural));
451	UnicodeString patternString;
452	patternString = cpi.getCurrencyPluralPattern(keyword, patternString);
453	PatternParser::parseToExistingProperties(
454	patternString,
455	pluralProperties,
456	IGNORE_ROUNDING_NEVER,
457	status);
458	affixesByPlural[plural].setTo(pluralProperties, status);
459	}
460	}
461
462	char16_t CurrencyPluralInfoAffixProvider::charAt(int32_t flags, int32_t i) const {
463	int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);
464	return affixesByPlural[pluralOrdinal].charAt(flags, i);
465	}
466
467	int32_t CurrencyPluralInfoAffixProvider::length(int32_t flags) const {
468	int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);
469	return affixesByPlural[pluralOrdinal].length(flags);
470	}
471
472	UnicodeString CurrencyPluralInfoAffixProvider::getString(int32_t flags) const {
473	int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);
474	return affixesByPlural[pluralOrdinal].getString(flags);
475	}
476
477	bool CurrencyPluralInfoAffixProvider::positiveHasPlusSign() const {
478	return affixesByPlural[StandardPlural::OTHER].positiveHasPlusSign();
479	}
480
481	bool CurrencyPluralInfoAffixProvider::hasNegativeSubpattern() const {
482	return affixesByPlural[StandardPlural::OTHER].hasNegativeSubpattern();
483	}
484
485	bool CurrencyPluralInfoAffixProvider::negativeHasMinusSign() const {
486	return affixesByPlural[StandardPlural::OTHER].negativeHasMinusSign();
487	}
488
489	bool CurrencyPluralInfoAffixProvider::hasCurrencySign() const {
490	return affixesByPlural[StandardPlural::OTHER].hasCurrencySign();
491	}
492
493	bool CurrencyPluralInfoAffixProvider::containsSymbolType(AffixPatternType type, UErrorCode& status) const {
494	return affixesByPlural[StandardPlural::OTHER].containsSymbolType(type, status);
495	}
496
497	bool CurrencyPluralInfoAffixProvider::hasBody() const {
498	return affixesByPlural[StandardPlural::OTHER].hasBody();
499	}
500
501
502	#endif /* #if !UCONFIG_NO_FORMATTING */