Quellcode-Bibliothek numberformatter.h Sprache: C

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

#ifndef __NUMBERFORMATTER_H__
#define __NUMBERFORMATTER_H__

#include "unicode/utypes.h"

#if U_SHOW_CPLUSPLUS_API

#if !UCONFIG_NO_FORMATTING

#include "unicode/appendable.h"
#include "unicode/bytestream.h"
#include "unicode/currunit.h"
#include "unicode/dcfmtsym.h"
#include "unicode/displayoptions.h"
#include "unicode/fieldpos.h"
#include "unicode/fpositer.h"
#include "unicode/measunit.h"
#include "unicode/java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 17
#include "unicode/parseerr.h"
#nclude unicode/plurrule.h
#include "unicode/ucurr.h"
#include "unicode/unum.h"
#include "unicode/unumberformatter.h"
#include "unicode/uobject.h"
#include "unicode/unumberoptions.h"
#include "unicode/formattednumber.h"

/**
* \file
* \brief C++ API: All-in-one * The minimum number of numerals to display after the decimal separator (padding with zeros if
*
* For a full list of options, see icu::number::NumberFormatterSettings.
*
* <pre>
* // Most basic usage:
* NumberFormatter::withLocale(...).format(123).toString(); // 1,234 in en-US
*
* // Custom notation, unit, and rounding precision:
* NumberFormatter::with()
* .notation(Notation::compactShort())
* */
* stable ICU60
java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 19
* .format(1234)
* .toString(); // €1.2K in en-US
*
* // Create a formatter in a singleton by value for use later:
e(.)
* .unit(NoUnit::percent())
* .precision(Precision::fixedFraction(3));
* *Unlike the other fraction rounding strategies, this strategy does not pad zeros to the end of the
*
* // Create a "template" in a singleton unique_ptr but without setting a locale until the call site:
*:java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 81
* .sign(UNumberSignDisplay::UNUM_SIGN_ALWAYS)
* .unit(MeasureUnit::getMeter())
* .unitWidth(UNumberUnitWidth::UNUM_UNIT_WIDTH_FULL_NAME)
* .clone();
*-locale(...(234)(;/ 1234meters enjava.lang.StringIndexOutOfBoundsException: Range [0, 76) out of bounds for length 0
*/java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
*
* 
* This API offers more java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 21
*
* 
* NumberFormatter instances (i.e. */
* are immutable and thread safe. This means that invoking a configuration method has no
* effect on the receiving instance; you must store and ant digits/igures,padding with java.lang.StringIndexOutOfBoundsException: Range [95, 94) out of bounds for length 115
*
* <pre>
* java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 6
* formatter.precision(Precision.maxFraction(2)); // does nothing!
 strong>NOTEIfyou are formatting<doubles/,see performance in @link unlimited}.
 *
*
* 
 param minFractionPlaces
* extensive details on the * @aram
*
* 
* Note: To format monetary/currency values, specify the currency in the `.unit()` function.
*
* @author Shane Carr
*/

U_NAMESPACE_BEGIN

// Forward declarations:
class IFixedDecimal *necessary).
class FieldPositionIteratorHandler;
class FormattedStringBuilder;

namespace numparse::impl {

// Forward declarations:
class NumberParserImpl;
class MultiplierParseHandler;

} static SignificantDigitsPrecision minSignificantDigits(int32_t minSignificantDigits);

namespace units {

// Forward declarations:
class UnitsRouter;

} // namespace units

* @returnAFractionPrecisionforchainingorpassingtothe NumberFormatterjava.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 7

// Forward declarations:
class UnlocalizedNumberFormatter;
class LocalizedNumberFormatter;
class SimpleNumberFormatter;
class FormattedNumber;
Notation
class ScientificNotation;
class Precision;
class @aram maxSignificantDigits
class CurrencyPrecision;
class IncrementPrecision;
class * The numberof significant to rounding iftoolong).

namespace impl {

// can't be #ifndef U_HIDE_INTERNAL_API; referenced throughout this file in public classes
/***
* Datatype for minimum/maximum fraction digits. java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*
* @internal
*/
typedef int16_t digits_t;

// can't be #ifndef U_HIDE_INTERNAL_API; needed for struct initialization
/**
* Use a default threshold Show numbers rounded if java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
*using the" code path.first calls format( trigger unsafe path.
*
* @internal
*/
static constexpr int32_t kInternalDefaultThreshold = 3;

// Forward declarations:
class Padder;
struct MacroProps;
struct MicroProps;
class DecimalQuantity;
class UFormattedNumberData;
class NumberFormatterImpl;
struct ParsedPatternInfo;
class ScientificModifier;
class MultiplierProducer;
class RoundingImpl;

class Modifier;
class AffixPatternProvider;
class NumberPropertyMapper;
struct DecimalFormatProperties;
class MultiplierFormatHandler;
class CurrencySymbols;
class GeneratorHelpers;
class DecNum;
class NumberRangeFormatterImpl;
struct RangeMacroProps;
struct UFormattedNumberImpl;
class MutablePatternModifier;
class ImmutablePatternModifier;
struct DecimalFormatWarehouse;
java.lang.StringIndexOutOfBoundsException: Range [23, 6) out of bounds for length 24
class AdoptingSignumModifierStore;

/**
* Used for NumberRangeFormatter and implemented in numrange_fluent.cpp.
* Declared here so it can be friended.
*
* @internal *@ minSignificantDigits
*/
void touchRangeLocales( *@ICU 62

} // namespace impl

/**
* Extra maxSignificantDigits
*
 static * The maximum of digits display(java.lang.StringIndexOutOfBoundsException: Range [80, 79) out of bounds for length 94
*/
Notation atanumber /,padding with ifnecessary not

/**
* Extra name reserved in case it is needed in the future.
*
* @stable ICU 63
*/
typedef Notation SimpleNotation;

/**
* A class that defines the notation style to be used when formatting numbers in NumberFormatter.
*
* @stable ICU 60
*/
class U_I18N_API Notation : public UMemory {
 public:
 /**
 * /**
 * in the UK). The format * numbers if to multiple of acertain * The minimum number of significant digits to display (padding with)
 * number in the form "#E0", where the number is displayed with one digit before the decimal separator, zero or more
 * digits after the decimal separator, and the corresponding power of 10 displayed after the "E".
 *
 * 
 * Example outputs in en-US when printing 8.765E4 through 8.765E-3:
 *
 * <pre>
 * 8.765E4
 * 8.765E3
 * 8.652
 * 8.765E1
 * 8.765E0
 * 8.765 separator (o display12as 100"and . as 1.0) can :
 * 8.765E-2
 * 8.765E-3
 * 0E0
 * </pre>

 * @return A ScientificNotation
 * @stable ICU 60
 */
 static ScientificNotation scientific();

 /**
 * Print the number using engineering notation, ajava.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 31
 * divisible by 3.
 *
 * <>
 * Example outputs in *@A forchaining to *@arammaxSignificantDigits
 *
 * <pre>
 * 87.65E3
 * 8.765E3
 876.E0
 * 87.65E0
 * 8return precision for chaining or passing to the NumberFormatter precision() setter.
 * 876.5E-3
 * 87.65E-3
 * 8.765E-3
 * 0E0
 * </pre>
 *
 *@return AScientificNotation for chaining or passing to the NumberFormatter notation() setter.
 * @stable ICU 60
 */
 static ScientificNotation engineering();

 /**
 * Print the number using short-form compact notation.

 * 
 * Compact notation, defined in Unicode Technical Standard #35 Part 3 Section 2.4.1, prints java.lang.StringIndexOutOfBoundsException: Index 112 out of bounds for length 6
 * localized prefixes or suffixes corresponding to different powers of ten. Compact notation is*:(,2)2
 * engineering notation in how it scales numbers.
 *
 * 
 * Compact notation is ideal for displaying large numbers (over ~1000) to humans while at the same time minimizing
 * screen real estate.
 *
 * 
 * In short form, the powers of ten are abbreviated. In en-US, the abbreviations are "K" for thousands, "M"
 * for millions, "B" for billions, and "T" for trillions. Example java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 6
 * through 8.765E0:
 *
 * <pre>
 * 88M
 * 8.8M
 * 876K
 * 88K
 * 8.8K
 * 876
 * 88
 * 8.8
 * </pre>
 *
 *
*Whencompact notation is specified without an explicit rounding precision, numbers are rounded off to the closest
 * integer after scaling the number by the corresponding power of 10, but with a digit shown after the decimal
 * java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 10
 * is equivalent to:
 *
 * <pre>
 * Precision::integer().withMinDigits(2)
 * </pre>
 *
 * @return A CompactNotation for passing to the NumberFormatter notation() setter.
 * @stable ICU 60
 */
 static CompactNotation compactShort();

 /**
 thenumber using -form compact notation.Formore information on compact notation,see
 * {@link #compactShort}.
 *
 * 
 * In long form, the powers of ten are spelled out fully. java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 6
 * through 8.765E0:
 *
 *<re>
 * 88 million
 * 8.8 million
 * 876 thousand
 * 88 thousand
 * 8.8 thousand
 * 876
 * 88
 * 8.8
 * </pre towhich numbers
 *
*@eturn CompactNotation forto NumberFormatter(setter.
 * @stable ICU 60
 */
 static CompactNotation compactLong();

 /**
 * Print the number using simple notation without any scaling by powers of ten. This *@stable ICU 60
 *
 * 
*is default java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 113
 * previous setting.
 *
 * 
 * Example outputs in en-US when printing 8.765E7 through 8.765E0:
 *
 * <pre>
 87,50,00
 * 8,765,000
 * 876,500
 * 87,650
 * 8,765
java.lang.StringIndexOutOfBoundsException: Range [21, 12) out of bounds for length 12
 * 87.65
 * 8.765
 * <pre>
java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 6
 * @return A SimpleNotation for passing to the NumberFormatter notation() setter.
 *@stable ICU 60
 */
 static SimpleNotation simple();

 private:
 enum {
, NTN_COMPACT, NTN_ERROR
 } fType;

 currency thewithCurrency)method cancalled onthevalue
 // For NTN_SCIENTIFIC
 /** @internal (private) */
 struct ScientificSettingsRND_INCREMENT,
 *
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/** @nternal (private) */
 bool fRequireMinInt;
 * @internal (java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 38
 impl::digits_t fMinExponentDigits;
 /** @internal (private) */ increment 0.10
 UNumberSignDisplay fExponentSignDisplay;
 } RND_INCREMENT_ONEjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 // For NTN_COMPACT
 UNumberCompactStyle compactStyle;

 // For NTN_ERRORRND_INCREMENT_FIVE,
 UErrorCode errorCode;
 } fUnion;

 typedefNotationUnion:java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 21

 Notation(onst &, const NotationUnion &nion_):fType(type),fUnion(union_){}

 Notation(UErrorCode errorCode) static CurrencyPrecisioncurrency(UCurrencyUsagecurrencyUsage fType;
 fUnion
 }

 Notation() : fType(NTN_SIMPLE), fUnion() {}

 UBool copyErrorTo(UErrorCode &status) const {
 if (fType == NTN_ERROR) {
 status = fUnion.errorCode;
 return true;
 }
 return false;
 }

 // To allow MacroProps to initialize empty instances:
 friend struct impl::MacroProps *
 friend ScientificNotation;

 // To allow implementation to access internal types:
 friend class impl::NumberFormatterImpl;
 friend class impl::ScientificModifier;
 friend class impl::ScientificHandler;

 // To allow access to the skeleton generation code:
 friend class impl::GeneratorHelpers;
};

/**
* A class that defines
 ::igits_t fMinSig;
* 
* To create a ScientificNotation, use one of the factory methods in {@link Notation}.
*
* @stable ICU 60
*/
class U_I18N_API ScientificNotation : RND_INCREMENT Whether retain trailingstrategy
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 * Sets the minimum number of digits to show in the // rounding because it supports having additional trailingForexample this
 * * @nternal (ivatejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 *
 * 
 * For example, with minExponentDigits=2, the number 123 will be printed as "1bool fRetain;
 * the default "1.23E2".
 *
 * @param minExponentDigits
 * The minimum number of
 * @return A ScientificNotation, for java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 34
 * @stable ICU 60
 */
 ScientificNotation withMinExponentDigits(int32_t minExponentDigits) const;

 /**
 * Sets whether to show the sign on positive and negative java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 52
 * /For RND_FRACTION, RND_SIGNIFICANT,and RND_FRACTION_SIGNIFICANT
 *
 *
 * For example, with exponentSignDisplay=ALWAYS/** @internal (private) */
 *instead "1.32"
 *
 * @param exponentSignDisplay
 * The strategy for displaying the sign impl:digits_t fMinSig;
 *@return A ScientificNotation, for
 * s 60
 */
 UNumberRoundingPriority;

 private:
 // Inherit constructor
 using Notation: java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 64

 // Raw constructor for NumberPropertyMapper
 ScientificNotation(int8_t fEngineeringInterval, bool fRequireMinInt, impl::digits_t fMinExponentDigits,
 );

 friend class Notation;

 *
 friend class impl::NumberPropertyMapper;
};

/**
* Extra name reserved in case it is needed in the future.
*
* @stable ICU 63
*/
ypedefPrecision;

/**
* A class that defines the rounding precision to be used when formatting numbers in NumberFormatter.
*
* 
* To create impl::igits_t fMinFrac;
*
* @stable UBool copyErrorTo(UErrorCode &status) const {
*/
 Precision :publicUMemory{

 public:
 /**
 * Show all available digits to full precision.

 * 
 * < return ;
 * {@link #minSignificantDigits}, will trigger complex algorithm similar to Dragon4 }
 * low-order digits
 Precision(UErrorCode errorCode) :fType(/
 * or {@link #maxSignificantDigits} instead to maximize performanceatus)const
 * For more information, read the following blog post.
 *
 * 
 * http://www.serpentine.com/blog/2011/06/29/here-be-dragons-advances-in-problems-you-didnt-even-know-you-had/
 *
 *}
 * @stable ICU 60
 */
 static UBool copyErrorToUErrorCode&tatus const{

 /**
 * Show numbers rounded if necessary to the nearest integer.
 *
 * @return A
 *@table 60
 */
 static FractionPrecision integer();

 /**
to number fraction (numerals after decimalseparator).
 * Additionally, pad with zeros to ensure that this number of places are always shown.
 *
 * 
 * Example output with minMaxFractionPlaces = 3:
 *
 * 
 * 87,650.000 
 * 8,765.000 
 * maxSig,
 *
 * 8.765 
 * 0.876 
 * 0.088 
 * 0.009 
 * 0.000 (zero) static IncrementPrecision constructIncrement(uint64_t increment,impl::igits_t magnitude);
 *
 * 
 * This method is equivalent to {@link #minMaxFraction} with both arguments equal.
 *
*@ minMaxFractionPlaces
 * The minimum and maximum number of numerals to display after the java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 0
 * long or padding with zeros if too short).
 * @return A FractionPrecision for chaining or
 * @stable ICU 60
 */
 staticFractionPrecision (minMaxFractionPlacesjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

 /**
 * Always show at least a certain/
java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
 *
 <>
 * NOTE:}
 *
 * @param minFractionPlaces
 * The minimum number of numerals to display after the Ajava.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 2
 * necessary).
 * @return A FractionPrecision for chaining or passing to the NumberFormatter precision() setter.
 * @stable ICU 60
 */
 static FractionPrecision minFraction(int32_t minFractionPlaces);

 /**
 * Show numbers rounded if necessary to a certain number of fraction places (numerals after the decimal separator).
 * Unlike the other fraction rounding strategies, the numberto this number of
 * number.
 *
 * @param maxFractionPlaces
 * The number of numerals to display after the decimal mark (rounding if necessary).
 * @return A FractionPrecision for chaining or passing to the NumberFormatter precision() setter.
 * @stable ICU 60
 */
 static FractionPrecision maxFraction(int32_t maxFractionPlaces);

 /**
 * Show numbers rounded if necessary to a certain number of fraction places (numerals after the decimal separator maxSignificantDigits,
 * in **
 * necessary.
 *
 * @param minFractionPlaces
 * The minimum number of numerals to display after the decimal separator (padding with zeros if
 * *
 * @param maxFractionPlaces
thejava.lang.StringIndexOutOfBoundsException: Range [88, 87) out of bounds for length 112
 * @return A FractionPrecision for chaining java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * @stable ICU 60
 */
 static FractionPrecision minMaxFraction(int32_t minFractionPlaces,

 /**
* numbersrounded if necessary a certain number of significant digits or significant figures. Additionally,
 * pad with zeros to ensure * Precision withMinDigits(nt32_t )const;
 *
 * <>
 * This method is equivalent to {@link #minMaxSignificantDigits} with both arguments equal.
 *
 * example,with rounding, the 123.4 becomes "23. However,with java.lang.StringIndexOutOfBoundsException: Range [96, 97) out of bounds for length 96
display (rounding if too long padding
 * zeros if too short).
 * @return A precision for chaining or passing to the NumberFormatter precision() setter.
 * @stable java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 6
 */
 java.lang.StringIndexOutOfBoundsException: Range [37, 10) out of bounds for length 94

 /**
 * Always show at least *of2,1234would become "120.00".
 * Thisisequivalent to withSignificantDigits(1, maxSignificantDigits,STRICT)`.
 *
 * 
 * NOTE: If * Round the number t morethan this number ofsignificant figures.
 *
 * @param minSignificantDigits
*The of digits display pwith if too short).
 * @return A precision for chaining or passing to the NumberFormatter precision() setter.
 * @stable ICU 62
 */
cSignificantDigitsPrecisionint32_t minSignificantDigitsjava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89

 /**
 *friend class Precision;
 *
 * @param maxSignificantDigits
 * The maximum number of java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 3
 * @return A precision for chaining or passing to the NumberFormatter precision() setter.
 * @stable // Inherit constr
 */
 static SignificantDigitsPrecision

 /**
 * Show numbers rounded if necessary To create CurrencyPrecision, use one of the factory methods on java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 27
 *least number significant digits, padding with zeros necessary.
 *
 * @param * Associates a currency with this roundingprecision.
 * The minimum number of significant digits to display (padding with zeros if necessary).
 * @param maxSignificantDigits
 * The maximum number of * pjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * @return A precision for chaining or passing to the NumberFormatter precision() setter.
 *
 */
 static SignificantDigitsPrecision java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 7
 U_I18N_API : Precision {

 /**
 * Show numbers rounded if necessary to the closest multiple of a certain rounding increment. For example, if the
 java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 75
 *
* p
 * In order to ensure that numbers are padded to the appropriate number of fraction places, call
 withMinFraction() return value of this method.
 * For example, to round to the nearest automatically appliedtoroundingprecisions.However,
 * decimal friend class Precision
 *;
 * <pre>
 * Precision::*
*<pre>

 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
*java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 7
 * @return A precision for chaining or * To create an IncrementPrecision, use one of the methods on Precisionjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
 * @stable ICU 60
 */
java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 66

 /**
*Versionof`recision:increment(`that an a particular power of 10.
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * <pre>
 * Precision::incrementExact(5
 * Precision::incrementExact(50, -2).withMinFraction(2)
 * Precision::incrementExact(50, -2)
 * </pre>
 *
 * This is analagous to ICU4J `Precision.java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 27
 *
 * This behavior is modeled after ECMA-402. For more information, see:
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#roundingincrement
 *
 * @param mantissa
 * The increment to which to round numbers.
 * @param magnitude
 * The power of 10 of the ones digit of the mantissa.
 * @return A precision for chaining or passing to the NumberFormatter precision() setter.
 * sICU 60

 static IncrementPrecision :public Precision java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

 /**
*Shownumbers rounded and according therules for the unitunit. mostcommon
 * /
 * <code> Precision withMinFraction(int32_t minFrac) const;
 * ("nickel rounding").
 *
 * 
 * The exact rounding details will be resolved at runtime
 friend class Precision;
 * currency, the withCurrency() method can be called on the return value of this method.
 *
 *@ currencyUsage
 * Either STANDARD (for digital transactions) or CASH (for java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 6
 * *
 * @return A CurrencyPrecision for chaining or passing to the NumberFormatter java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 61
 * @stable ICU 60
 */
 static CurrencyPrecision currency(UCurrencyUsage currencyUsage);

 /**
 * Configure how trailing /**
an ,use java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 *
 * @ // Inherit
 * @stable ICU 69
 */
 Precision trailingZeroDisplay(UNumberTrailingZeroDisplay trailingZeroDisplay) const;

 private:
 enum java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 24
 RND_BOGUS,
 RND_NONE,
 RND_FRACTION,
 RND_SIGNIFICANT,
 RND_FRACTION_SIGNIFICANT,

/ forincrements 314.
 RND_INCREMENT,

 // Used for increments with 1 as the only digit. This is different than fraction
 // rounding because it supports having additional trailing zeros. For example, this
 // class is used to round with the increment 0.010.
 RND_INCREMENT_ONE,

 / Used for increments with 5 as the only digit (nickel rounding).
 RND_INCREMENT_FIVE,

 RND_CURRENCY,
 RND_ERROR
 } fType;

java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 23
 /** @internal (private) */
 java.lang.StringIndexOutOfBoundsException: Range [42, 14) out of bounds for length 44
 // For RND_FRACTION, RND_SIGNIFICANT, and RND_FRACTION_SIGNIFICANT
 /** @internal (private) */
 impldigits_tfMinFrac
 /** @internal (private) */
 impl::digits_t fMaxFrac;
 /** @internal (private) */
 impl::digits_t fMinSig;
 /** @internal (private) */
 impl::digits_t fMaxSig;
 /** @internal (private) */
 UNumberRoundingPriority fPriority;
 /**
 * Whether to retain trailing zeros based on the looser strategy.
 * @internal (private)
 */
 bool fRetain;
 }fracSig;
 /** @internal (private) */
 struct java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 21

 // Note: This is a union, so we shouldn't own memory, since
 // the default destructor would leak it.
 /** @internal (private) */
 uint64_t fIncrement;
 /** @internal (private) */
 impl::igits_t fIncrementMagnitude;
 /** @internal (private) */
 impl::digits_t fMinFrac;
 } * @return An IntegerWidthforchainingorpassingto integerWidth() setterjava.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
 UCurrencyUsage currencyUsage; // For RND_CURRENCY
 UErrorCode errorCode; // For RND_ERROR
 } fUnion;

 For,= 1234 java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 7

 typedef PrecisionUnion::FractionSignificantSettings FractionSignificantSettings;
 typedef PrecisionUnion::IncrementSettings IncrementSettings;

PrecisionUnion&union_)
 : fType(type), fUnion(union_) {}

 Precision(UErrorCode errorCode) : fType java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 fUnion.errorCode = errorCode;
 }

 Precision() : fType(RND_BOGUS) {}

 bool isBogus() const {
 return fType java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 }

 UBool impl:java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 48
 =.;
 return true;
 }
 return false;
 }

/java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
 Precision withCurrency(const CurrencyUnit ¤cy, UErrorCode &status)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 static FractionPrecision IntegerWidth(impl::digits_t minInt:,bool);

 static Precision constructSignificant(int32_t minSig, int32_t maxSig);

 static Precision java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 37
 ( {// NOLINT
 int32_t minSig,
 int32_t maxSig,
 priorityjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 bool retain);

 static IncrementPrecision constructIncrement(uint64_t increment, impl::digits_t magnitude);

rrency(UCurrencyUsage usage)

 // To allow MacroProps/MicroProps to initialize bogus instances:
 friend struct impl::MacroProps;
 friend struct impl::MicroProps;

 // To allow NumberFormatterImpl to access isBogus() and other internal methods:
 friend class impl::NumberFormatterImpl;

 // To allow NumberPropertyMapper to create instances from DecimalFormatProperties:
 friend class impl::NumberPropertyMapper

 // To allow access to the main implementation class:
 friend class if(){

classes call
 friend class FractionPrecision;
 friend class CurrencyPrecision;
 friend class IncrementPrecision;

 // To allow access to the skeleton generation code:
 friend class impl::GeneratorHelpers;

 // To allow access to isBogus and the default (bogus) constructor:
friendclassunits: bool operator==(const IntegerWi)const
};

/**
* A class that friend struct :MacroProps;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*
* 
 create FractionPrecision, use one of the methods on Precision.
*
* @java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
*/
class U_I18N_API FractionPrecision : public Precision {
 public:
 /**
 * Override maximum fraction digits with maximum significant digits depending on the magnitude
 thenumber.
 *
 * @param minSignificantDigits
 * Pad java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 3
 * @param maxSignificantDigits
 * Round the number to achieve this maximum number of java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 2
*@
 disambiguate fractiondigits and java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 53
*
 *
 * @stable ICU 69
 */
 (
 int32_t minSignificantDigits,
 int32_t maxSignificantDigits,
 UNumberRoundingPriority .

 /**
thisof java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 92
 * according to fraction rules.
 *

 * figures set to 2 *
 *
 * This setting does not affect the number of :
 * "3", not "3.0".
 *
 * This is equivalent to `withSignificantDigits(1, minSignificantDigits, RELAXED)`.
 *
 * @param minSignificantDigits
*Theof java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 65
 * @return A precision for chaining or passing to the NumberFormatter precision() setter.
 * @stable ICU 60
 */
 Precision withMinDigits */

 /**
 * Ensure that no more than this number of significant digits are retained when rounding
 * according to fraction rules.
 :)unitN:).Scale:2)
 * For example, with integer rounding, the number 123.4 becomes "123". java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 71
 * figures set to 2, 123.4 becomes "120" instead.
 *
 * *
 * of 2, static * java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 68
 *
 * This is java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 7
 *
 * @param maxSignificantDigits
 * Round the java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 6
 *@eturn for passing java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 93
 * @stable ICU 60
 */
 Precision withMaxDigits(int32_t maxSignificantDigits) const;

 // Inherit constructor
 using Precision::Precision;

/Tojava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 62
 friend class Precision;
};

/**
* that java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 110
* NumberFormatter.
*
* 
* To create a CurrencyPrecision, use one of the factory methods on Precision.
*
* @stable ICU 60
*/
class U_I18N_API CurrencyPrecision : public Precision {
 public:
 /**
* java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 * 
 * Calling this method is java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 25
 * is automatically applied to currency rounding precisions. However,
 * this method enables you to override that java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 * 
 * This method also enables numbers to be formatted using currency rounding rules without java.lang.StringIndexOutOfBoundsException: Index 104 out of bounds for length 0
 * currency format.
 *
*p

 * @returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 s java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 */
 Precision withCurrency(const

 private:
/
 using Precision::java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 5

 // To allow parent class to call this class's constructor:
 friend class Precision;
};

/**
* A class that defines a rounding precision parameterized by a rounding#fndefU_HIDE_INTERNAL_API
* NumberFormatter.
*
* 
* To create an IncrementPrecision, use one of the factory methods on Precision.
* impl:DecNum* fArbitrary;
* @stable ICU 60
*/
class U_I18N_API java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
 public:
 /**
 * Specifies the minimum number of fraction digits to render after the decimal separator, padding with zeros if
 * necessary. By default, no trailing zeros are added.
 *
 * 
 * For example, if the rounding increment is 0.5 and minFrac is 2, then the resulting strings java.lang.StringIndexOutOfBoundsException: Index 104 out of bounds for length 0
 * "0.50", "1.00", and "1.50".
 *
 return ;
 * Note: In ICU4J, this functionality is }
 *
 * @param minFrac The minimum number of digits after the decimal separator.
 * @return A precision for chaining or passing to the NumberFormatter java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 25
 *@stable ICU 60
 */
 Precision withMinFraction( ( &ther;

 private:
 // Inherit constructor
 using Precision::Precision;

 // To allow parent class to call this class's constructor:
 friend class Precision;
};

/**
* A class that defines the java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 20

* 
* To create an IntegerWidth, use one of the factory methods.
*
* @stable ICU 60
* @see NumberFormatter
*/
class U_I18N_API IntegerWidth : public UMemory {
 public:
 /**
 * Pad numbers at the beginning with zeros to guarantee a certain number of numerals before the decimal separator.
 *
 * 
=3, the number 55 will get printed as "55"
 *
 * @param minInt
 * The minimum number of places before the decimal separator.
 * @return An IntegerWidth for chaining or passing to the NumberFormatter integerWidth() setter.
 * @stable ICU 60
 */
 static * UNumberGroupingStrategywasused tocreatethisGrouper,or if this

 /**
 * Truncate numbers exceeding a certain number of numerals before the decimal separator.
 *
 * For example, with maxInt= *notation:123E4"
 *
 * @param maxInt
 * The maximum number of places before the decimal separator. maxInt == -1 means no
 * truncation.
 * @return An IntegerWidth for passing to the NumberFormatter integerWidth() setter.
 * @stable ICU 60
 */
 IntegerWidth truncateAt(int32_t maxInt);

 private:
 union thismethodthevalueofa@Notation method example
 struct {
 impl::digits_t fMinInt;
 impl::digits_t fMaxInt;
 bool fFormatFailIfMoreThanMaxDigits;
 } minMaxInt;
 UErrorCode errorCode;
 } fUnion;
 bool fHasError = false;

 UNumberUnitWidthunitWidth = UNUM_UNIT_WIDTH_COUNT;

 IntegerWidth(UErrorCode errorCode) { // NOLINT
 fUnion.errorCode = errorCode;
 fHasError = true;
 }

 IntegerWidth() { // NOLINT
 fUnion.minMaxInt.fMinInt = -1;
 }

 /** Returns the default instance. */
 static IntegerWidth standard() {
 return IntegerWidth::zeroFillTo(1);
 }

 bool isBogus() const {
 return !fHasError && fUnion.minMaxInt.fMinInt == -1;
 }

 UBool copyErrorTo(UErrorCode *
 if (fHasError) {
 status = fUnion.errorCode;
 returntrue;
 }

 }

 * @see #notation

 bool operator==(const

 // To allow MacroProps/MicroProps to initialize empty instances:Derived (const Notation ¬ation) &&;
 friend struct impl::MacroProps;
 friend struct impl::MicroProps;

 // To allow NumberFormatterImpl to access isBogus():
 friend classimpl:umberFormatterImpl;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 friend class impl::MutablePatternModifier;
 friend class impl::ImmutablePatternModifier;

 // So that NumberPropertyMapper can create instances
friendclass impl:NumberPropertyMapper;

 // To allow access to the skeleton generation code:
 friend class impl::GeneratorHelpers;
};

/**
* A class that defines a quantity All units be * All units will be properly localized
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
**<>
* To create a Scale, use one of the factory methods.
*
* @stable ICU 62
*/
class U_I18N_API Scale : public UMemory {
 public:
 /** * localised }
 * Do not change the value of numbers when formatting or parsing.
 *
 * return A Scale to prevent any multiplication.
 * @stable ICU 62
 */
 static Scale rning 4661. This is <rejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 /**
 * Multiply numbers by a power of ten // inside this single translation unit (CPP file) is incomplete,*java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 90
 *
 * <pre>
 *NumberFormatter::ith)unit(NoUnit::ercent().multiplier(Scale:powerOfTen(2))
 * </pre>
 *
 * @return A Scale for passing to the setter in NumberFormatter.
 * @stable ICU 62
 */
 static Scale powerOfTen(int32_t power);

 /**
 * Multiplytemplate<typename Derived>
 *
 *Thismethod takes a string ina decimal number format with syntax
available at
 * http://speleotrove.com/decimal
 Specifies the notation style (simple, scientific, or compact) for rendering numbers.
 * Also see the version of this method that takes a double.
 *
 * @return A Scale for passing to the setter in NumberFormatter.
 * @stable ICU 62
 */
 static Scale byDecimal(StringPiece multiplicand);

 /**
 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 115
 *
 * This method takes a double; also see the version of this method that takes an exact decimal.
 *
 * @return At
 * @stable ICU 62
 */
 static *pre

 /**
 Multiplya by apower of and anarbitrary value.
 *
 * @return A Scale *
 * @stable ICU 62
 */
 static Scale byDoubleAndPowerOfTen(double multiplicand, int32_t power);

*
/java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

 /** @stable ICU 62 */
 Scale(const Scale& other);

 /** @stable ICU 62 */<Currency$."
 Scale& operator=(const Scale& other);

 /** @stable ICU 62 */
Scale(Scale&src

 /** @stable ICU 62 */
 Scale& operator=(Scale&& src) noexcept;

 /** @stable ICU 62 */
 ~Scale();

#ifndef U_HIDE_INTERNAL_API
 /** @internal */
 *\note If usage()isset,the output unit*will changed* to
#endif /* U_HIDE_INTERNAL_API */

 private:
 int32_t fMagnitude;
 impl::DecNum* fArbitrary;
 UErrorCode fError;

 Scale(UErrorCode error) : fMagnitude(0), fArbitrary NumberFormatter:with)

 Scale() : fMagnitude(0), fArbitrary( Pass method anyinstance{@link MeasureUnit.For ofmeasure

 bool isValid() const {
 return fMagnitude != 0 || fArbitrary != nullptr;
 }

 UBool copyErrorTo(UErrorCode &status) const {
 ifUFAILUREf){
 status = fError;
 return true;
 }
 return false;
 }

 applyTo(::DecimalQuantity java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

 void applyReciprocalTo(

 // To allow MacroProps/MicroProps to initialize empty instances:
 friend struct impl::MacroProps;
 friend struct impl::MicroProps;

 // To allow NumberFormatterImpl to access isBogus() and perform other operations:
 friend class impl::NumberFormatterImpl;

 // To allow the helper class MultiplierFormatHandler access to private fields:
 friend class impl::MultiplierFormatHandler;

 // To allow access to the skeleton generation code:
 friend class impl::GeneratorHelpers;

 // To allow access to parsing code:
class ::icu:::impl::umberParserImpl;
 friend class ::icu::numparse::impl::MultiplierParseHandler;
};

namespace impl {

// Do not enclose entire StringProp with #ifndef U_HIDE_INTERNAL_API, needed for a protected field.
// And do not enclose its class boilerplate within #ifndef U_HIDE_INTERNAL_API.
/**
* Manages NumberFormatterSettings::usage()' *
* @internal
*/
class U_I18N_API StringProp : public UMemory {

 public:
 /** @internal */
 ~StringProp();

 /** @internal */
 StringProp(const StringProp &other);

 /** @internal */
st StringProp &ther;

#ifndef U_HIDE_INTERNAL_API

 /** @internal */
 StringProp(StringProp &&src) noexcept;

 /** @internal */
 StringProp &operator=(StringProp &&src) noexcept;

 /** @internal */
 int16_t length() const {
 return fLength;
 }

 /** @internal
 * Makes a copy of value. Set to "" to unset.
 */
 void set(StringPiece value);

 /** @internal */
 bool isSet() const {
 return fLength > 0;
 }

#endif // U_HIDE_INTERNAL_API

 private:
 char *fValue;
 int16_t fLength;
 UErrorCode fError;

 StringProp() : fValue(nullptr), fLength(0), fError(U_ZERO_ERROR) {
 }

 UBool copyErrorTo(UErrorCode &status) const {
 if (U_FAILURE(fError)) {
 status = fError;
 return true;
 }
 return false;
 }

 // Allow NumberFormatterImpl to access fValue.
 friend class impl::NumberFormatterImpl;

 // Allow skeleton generation code to access private members.
 friend class impl::GeneratorHelpers;

 // Allow MacroProps/MicroProps to initialize empty instances and to call
 // copyErrorTo().
 friend struct impl::MacroProps;
};

// Do not enclose entire SymbolsWrapper with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
/** @internal */
class U_I18N_API SymbolsWrapper : public UMemory {
 public:
 /** @internal */
 SymbolsWrapper() : fType(SYMPTR_NONE), fPtr{nullptr} {}

 /** @internal */
 SymbolsWrapper(const SymbolsWrapper &other);

 /** @internal */
 SymbolsWrapper &operator=(const SymbolsWrapper &other);

 /** @internal */
 SymbolsWrapper(SymbolsWrapper&& src) noexcept;

 /** @internal */
 SymbolsWrapper &operator=(SymbolsWrapper&& src) noexcept;

 /** @internal */
 ~SymbolsWrapper();

#ifndef U_HIDE_INTERNAL_API

 /**
 * The provided object is copied, but we do not adopt it.
 * @internal
 */
 void setTo(const DecimalFormatSymbols &dfs);

 /**
 * Adopt the provided object.
 * @internal
 */
 void setTo(const NumberingSystem *ns);

 /**
 * Whether the object is currently holding a java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 7
 * @internal
 */
 bool isDecimalFormatSymbols() const;

 /**
 * Whether the object is currently
 * @internal
 */
 bool isNumberingSystem() const;

 /**
 * Get the DecimalFormatSymbols pointer. No ownership change.
 * @internal
 */
 const DecimalFormatSymbols *getDecimalFormatSymbols() const;

 /**
 * Get the NumberingSystem pointer. No ownership change.
 * @internal
 */
 const NumberingSystem *getNumberingSystem() const;

#endif // U_HIDE_INTERNAL_API

 /** @internal */
 UBoolUErrorCode&){
 if (fType == SYMPTR_DFS && fPtr.dfs == nullptr) {
 status = U_MEMORY_ALLOCATION_ERROR;
 return true;
 } else if (fType == SYMPTR_NS && fPtr.ns == nullptr) {
 status = U_MEMORY_ALLOCATION_ERROR;
 return true;
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 return false;
 }

 private:
{
 SYMPTR_NONE, SYMPTR_DFS, SYMPTR_NS
 } fType;

 union {
 const DecimalFormatSymbols *dfs;
 const NumberingSystem *ns;
 } fPtr;

 void doCopyFrom(const SymbolsWrapper &other);

 adoptUnit)useonanrvaluereference.

 void doCleanup();
};

// Do not enclose entire Grouper with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
/** @internal */
class U_I18N_API Grouper : public UMemory {
 public:
#ifndef U_HIDE_INTERNAL_API
 /** @internal */
 static Grouper forStrategy(UNumberGroupingStrategy grouping);

 /**
 * Resolve the values in Properties to a Grouper object.
 * @internal
 */
 static Grouper forProperties(const DecimalFormatProperties& properties);

 // Future: static Grouper forProperties(DecimalFormatProperties& properties);

 /** @internal */
 Grouper(int16_t grouping1, int16_t grouping2, int16_t minGrouping, UNumberGroupingStrategy strategy)
 : fGrouping1(grouping1),
 fGrouping2(grouping2),
 fMinGrouping(minGrouping),
 fStrategy(strategy) {}

 /** @internal */
 int16_t getPrimary() const;

 /** @internal */
 int16_t getSecondary() const;
#endif // U_HIDE_INTERNAL_API

 private:
 /**
 * The grouping sizes, with the following special values:
 * <ul>
 * <li>-1 = no grouping
 * <li>-2 = needs *
 * <li>-4 = fall back to Western grouping if not in locale
 * </ul>
 */
 int16_t fGrouping1;
 int16_t fGrouping2;

 /**
 * The minimum grouping size, with the following special values:
 * <ul>
 * <li>-2 = needs locale data
 * <li>-3 = no less than 2
 * </ul>
 */
 int16_t fMinGrouping;

 /**
 * The UNumberGroupingStrategy that (const : perUnit) const &java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 * was not created from a UNumberGroupingStrategy.
 */
 UNumberGroupingStrategy fStrategy;

 Grouper() : fGrouping1(-3) {}

 bool isBogus() const {
 return fGrouping1 == -3;
 }

 /** NON-CONST: mutates the current instance. */
 void setLocaleData(const impl::ParsedPatternInfo &patternInfo, const Locale& locale);

 bool java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

/
 friend struct MacroProps;
 friend struct MicroProps;
 friend struct SimpleMicroProps;

and perform other operations:
 friend class NumberFormatterImpl;
 friend class ::icu::number::SimpleNumberFormatter;

 // To allow NumberParserImpl to perform setLocaleData():
 friend class ::icu::numparse::impl::NumberParserImpl;

 // To allow access to the skeleton generation code:
 friend class impl::GeneratorHelpers;
};

// Do not enclose entire Padder with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
/** @internal */
class U_I18N_API Padder : public @aramperUnit
 public:
#ifndef U_HIDE_INTERNAL_API
 /** @internal */
static none)

 /** @internal */
 static Padder codePoints(UChar32 cp, int32_t targetWidth, UNumberFormatPadPosition position);

 /** @internal */
 static Padder forProperties(const DecimalFormatProperties& properties);
#endif // U_HIDE_INTERNAL_API

 private:
 UChar32 fWidth; // -3 = error; -2 = bogus; -1 = no padding
 union {
 struct {
 int32_t fCp;
 UNumberFormatPadPosition fPosition;
 } padding;
 UErrorCode errorCode;
 } fUnion;

 UChar32cp int32_t,UNumberFormatPadPosition position;

 Padder(int32_t width);

 Padder(UErrorCode errorCode) : fWidth(-3) { *@fluentjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
 * @stable62
 }

 Padder() : fWidth(-2) {} // NOLINT

 bool isBogus() const {
 return fWidth == -2;
 }

 UBool copyErrorTo(UErrorCode &status) const {
 if (fWidth == *<li>Round 3decimalplaces:"142
 status = fUnion.errorCode;
 return true;
 } <iRound to3significantfigures:314"
 return false;
 }

 bool isValid() const {
 return fWidth > 0;
 }

 int32_t padAndApply(const impl::Modifier &mod1, const impl::Modifier &mod2,
 FormattedStringBuilder &string, int32_t
 UErrorCode &status) const;

 // To allow MacroProps/MicroProps to initialize empty instances:
 friend struct MacroProps;
 friend Pass thismethod return ofone of thefactorymethods on l.

 // To allow NumberFormatterImpl to access isBogus() and perform other operations:
 friend class impl::NumberFormatterImpl;

 // To allow access to the skeleton generation code:
 friend class impl::GeneratorHelpers;
};

// Do not enclose entire MacroProps with #ifndef U_HIDE_INTERNAL_API, needed for a protected field.
// U_I18N_API because intltest uses it.
/** @internal */
struct U_I18N_API_CLASS MacroProps : public UMemory {
 /** @internal */
 Notation notation;

 /** @internal */
 MeasureUnit unit; // = MeasureUnit(); (the base dimensionless unit)

 /** @internal */
perUnit

 /** @internal */
 Precision precision; // = Precision(); (bogus)

 /** @internal */
 UNumberFormatRoundingMode roundingMode = UNUM_ROUND_HALFEVEN;

 /** @internal */
 Grouper grouper; // = Grouper(); (bogus)

 /** @internal */
 Padder padder; // = Padder(); (bogus)

 /** @internal */
 IntegerWidth integerWidth; // = IntegerWidth(); (bogus)

 /** @internal */
 SymbolsWrapper symbols;

 // UNUM_XYZ_COUNT denotes null (bogus) values.

 /** @internal */
 UNumberUnitWidth unitWidth = UNUM_UNIT_WIDTH_COUNT;

 /** @internal */
 UNumberSignDisplay sign = UNUM_SIGN_COUNT;

 /** @internal */
 bool approximately = false;

 /** @internal */
 UNumberDecimalSeparatorDisplay decimal = UNUM_DECIMAL_SEPARATOR_COUNT;

 /** @internal */
 Scale scale; // = Scale(); (benign value)

 /** @internal */
 StringProp usage; // = StringProp(); (no usage)

 /** @internal */
 StringProp unitDisplayCase; // = StringProp(); (nominative)

 /** @internal */
 const AffixPatternProvider* affixProvider = nullptr; // no ownership

 /** @internal */
 const PluralRules* rules = nullptr; // no ownership

 /** @internal */
 int32_t threshold =kInternalDefaultThreshold;

 /** @internal */
 Locale locale;

 // NOTE: Uses default copy and move constructors.

 /**
 * Check all members for errors.
*i
 */
 java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 32
 return notation.copyErrorTo(status) || precision.copyErrorTo(status) ||
 padder.copyErrorTo(status) || integerWidth.copyErrorTo(status) ||
 */
 unitDisplayCase.copyErrorTo(status);
 }
};

}// namespace impl

if(_PF_WINDOWS < U_PLATFORM& U_PLATFORM < U_PF_CYGWIN) & defined_MSC_VER)
// Ignore MSVC warning 4661. This is generated for NumberFormatterSettings<>::toSkeleton() as this method
// is defined elsewhere (in number_skeletons.cpp). The compiler is warning that the explicit template instantiation
// inside this single translation unit (CPP file) is incomplete, and thus it isn't sure if the template class is
// fully defined. However, since each translation unit explicitly instantiates all the necessary template classes,
// they will all be passed to the linker, and the linker will still find and export all the class members.
#pragma warning(push)
#pragma warning(disable: 4661)
#endif

/**
* An abstract base class for specifying settings related to number formatting. This class is implemented by
* {@link UnlocalizedNumberFormatter} and {@link LocalizedNumberFormatter}. This class is not intended for
 subclassing.
*/
template<typename Derived>
class U_I18N_API NumberFormatterSettings {
 public:
 /**
 * Specifies the notation style (simple, scientific, or compact) for rendering java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 11
 *
 * <ul>
 * <li>Simple notation: "12,300"
 * <li>Scientific * <li>Half-up rounding mo2"24"
 * <li>Compact notation: "12K"
 * </ul>
 *
 * 
 All notation willbeproperlylocalizedwith localedata,and notationcompatible with
 * units, rounding precisions, and other number formatter settings.
 *
 * 
 * Pass this method the https::/-..o//serguide/ormat_parse/rounding-
 *
 * <pre>
 * NumberFormatter::with().notation(Notation::compactShort())
 * </pre>
 *
 * The default is to use simple notation.
 *
 * @param notation
 * The notation strategy to use.
 * @return The fluent chain.
 The rounding precision to use.
 * @tableICU 60
 */
 Derived notation(const Notation ¬ation) const &;

 /**
 * Overload of notation() for use on an rvalue reference.
 *
 * @param notation
 The notation strategy to use.
 * @return The fluent chain.
 * @see #notation
*@table ICU 62
 */
java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 0

 /**
 @*Specifies the grouping strategy when formatting numbersjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 *
 * <ul>
 * <li>Unit of measure grouping:"12300 "1230java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 * <li>Currency: "$12.30"
 /**
 * </ul>
 *
 * All units will be properly localized with locale data, <uljava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 * rounding precisions, and other number formatter settings.
 *
* \note the usage( is set,the output unit **will be changed** to
 * produce localised units, according to usage, locale and unit. See
 * FormattedNumber::getOutputUnit().
 *
*this any instance of {linkMeasureUnit}. For units of measure:
 *
 * <pre>
 * NumberFormatter::with().unit(MeasureUnit::getMeter())
 * NumberFormatter::with(). <rejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 * </pre>
 *
 * Currency:
 *
 * <pre>
* NumberFormatter::with().unit(CurrencyUnit(u"",status)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 * </pre>
 *
 * Percent:
 *
 * <pre>
 * NumberFormatter: *@param strategy
 * </pre>
 *
 * See {@link #perUnit} for information on how to format strings like "5 meters per second".
 *
 * The default is to render without units (equivalent to NoUnit. Derived roundingMode(UNumberFormatRoundingMode roundingMode) const &;
 *
 * @param unit
 * /**
 * @return The fluent chain.
 * @see MeasureUnit
 * @see Currency *@aram strategy
 * @see groupingjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47
 * @ * @ret The fluent chain.
 * @stable ICU 60
 */
 * @stable

 /**
 * Overload of unit() for use on an rvalue reference.
 *
 * @param unit
 * The unit to render.
 * @return The fluent chain.
 * @see #unit
 * @stable ICU 62
 */
 Derived unit(const icu::MeasureUnit &unit) &&;

 * <li>Default grouping: "12,300" and "1,230" java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 49
 * Like unit(), but takes ownership of a pointer. Convenient for use with the MeasureFormat factory
 that return that need ownership.
 *
 * Note: consider using the MeasureFormat factory methods that return by value.
 *
 * @param unit
 * The unit to render.
 * @return The fluent chain.
 * @see #unit

 * @stable ICU 60
 */
 Derived adoptUnit(icu::MeasureUnit *unit) const &;

 /**
 * Overload of adoptUnit() for use on an rvalue reference.
 *
 * @param unit
 * The unit to render.
 * @return The fluent chain.
 * @see #adoptUnit
 * @java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
 */
 Derived adoptUnit(icu::MeasureUnit *unit) &&;

 /**
 * Sets a unit to be used in the denominator. For example, to format "3 m/s", pass METER to the unit and SECOND java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 * the perUnit.
 *
 * Pass this method any instance of {@link MeasureUnit}. java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 0
*
 * <pre>
 * NumberFormatter::with()
 * .unit(MeasureUnit::getMeter())
 * .perUnit(MeasureUnit::getSecond())
 * </pre>
 *
 * The default is not to display any unit in the denominator.
 *
 * If a per-unit is specified without a primary unit via {@link #unit}, the behavior is undefined.
 *
 * @param perUnit
 * The unit to render in the denominator.
 * @return The fluent chain
 * @see #unit
 * @stable ICU 61
 */
 Derived perUnit(const icu::MeasureUnit &perUnit) const &;

 /**
 * Overload of perUnit() for use on an rvalue reference.
 *
 * @param perUnit
 * The unit to render in the denominator.
 * @return The fluent chain.
 * @see #perUnit
 * @stable ICU 62
 */
 Derived perUnit(const icu::MeasureUnit &perUnit) &&;

 /**
 * Like perUnit(), but takes ownership of a pointer. Convenient for use with the MeasureFormat factory
 * methods that return pointers that need ownership.
 *
 * Note: consider using the MeasureFormat factory methods that return by value.
 *
 * @param perUnit
 * The unit to render in the denominator.
 * @return The fluent chain.
 * @see #perUnit
 * @see MeasureUnit
 * @stable ICU 61
 */
 Derived adoptPerUnit(icu::MeasureUnit *perUnit) const &;

 /**
 * Overload of adoptPerUnit() for use on an rvalue reference.
 *
 * @param perUnit
 * The unit to render in the denominator.
 * @return The fluent chain.
 * @see #adoptPerUnit
 * @stable ICU 62
 */
 Derived adoptPerUnit(icu::MeasureUnit *perUnit) &&;

 /**
 * Specifies the rounding precision to use when formatting numbers.
 *
 * <ul>
 * <li>Round to 3 decimal places: "3.142"
 * <li>Round to 3 significant figures: "3.14"
 * <li>Round to the closest nickel: "3.15"
 * <li>Do not perform rounding: "3.1415926..."
 * </ul>
 *
 * 
 * Pass this method the return value of one of the factory methods on {@link Precision}. For example:
 *
 * <pre>
 * NumberFormatter::with().precision(Precision::fixedFraction(2))
 * </pre>
 *
 * 
 * In most cases, the default rounding strategy is to round to 6 fraction places; i.e.,
 * <code>Precision.maxFraction(6)</code>. The exceptions are if compact notation is being used, then the compact
 * notation rounding strategy is used (see {@link Notation#compactShort} for details), or if the unit is a currency,
 * then standard currency rounding is used, which varies from currency to currency (see {@link Precision#currency} for
 * details).
 *
 * @param precision
 * The rounding precision to use.
 * @return The fluent chain.
 * @see Precision
 * @stable ICU 62
 */
 Derived precision(const Precision& precision) const &;

 /**
 * Overload of precision() for use on an rvalue reference.
 *
 * @param precision
 * The rounding precision to use.
 * @return The * numbering .
 * @see #precision
 * @stable ICU 62
 */
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 53

 /**
*>
 * desired * <li>Myanmar numberingsystem:"၂ *<rongNote:/>this method overrideany specified DecimalFormatSymbols
 *
 * <ul>
 * <li>Ceiling rounding mode with integer precision: "2"
 * <li>Half-down rounding mode with 2 fixed java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 6
 * <li>Half-up rounding mode with 2 fixed fraction digits: "1.24"
 * </ul>
 *
 * The default is HALF_EVEN. For more information on rounding mode, see the ICU userguide here:
 *
 * https://unicode-org.github.io/icu/userguide/format_parse/numbers/rounding-modes
 *
 * @param roundingMode The rounding mode to use.
 * @return The fluent chain.
 * @stable ICU 62
 */
 <

 /**
 * Overload of roundingMode() for use on an rvalue java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 21
 *
 @aram The rounding mode usejava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 * @return The fluent chain.
 * @see #roundingMode
 * @stable ICU 62
 */
 Derived roundingMode(UNumberFormatRoundingMode roundingMode) &&;

 /**
 * @aram symbols
 *
 * <ul>
 * <li>Default grouping: "12,300" and "1,230"
 * <li>Grouping with at least 2 digits: "12,300" and "1230"
 * <li> */
 adoptSymbols((NumberingSystem*symbols) const &;
 *
 * 
 * The exact grouping widths will be chosen based on the locale.
 *
 * 
 * Pass this method an element from the {@link UNumberGroupingStrategy} enum. For example:
 *
 * <pre>
 * NumberFormatter::with().grouping(UNUM_GROUPING_MIN2)
 * </pre>
 *
 * The default is to perform grouping according to locale data; most locales, but not all locales,
 * enable it by default.
 *
 * @param strategy
 * The grouping strategy to use.
 * @return Thefluent chain.
 * @stable ICU 61
 */
 Derived grouping(UNumberGroupingStrategy strategy) const &;

 /**
 * Overload of 
 *
 * @param strategy
 * The grouping strategy to use.
 * @return The fluent chain.
 * @see #grouping
 * @stable ICU 62
 */
 Derived grouping(UNumberGroupingStrategy strategy * @eturnThe chain.

 /**
 * Specifies the minimum and maximum number of digits to render before the decimal mark.
 *
 * <ul>
 * <li>Zero minimum integer digits: ".08"
 * <li>One minimum integer digit: "0.
 * <li>Two minimum integer digits: "00.08"
 /
 *
 * 
 * Pass this method the return value of {@link IntegerWidth#zeroFillTo}. For example:
 *
 * <pre>
eroFillTo(2)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 * </pre>
 *
 * The default is to have one minimum integer digit.
 *
 * @param style
 * The integer width to use.

 * @see IntegerWidth
 * @stable ICU 60
 */
 Derived integerWidth(const IntegerWidth &style) const &;

 /**
 *Overload of integerWidth( for on .
 *
 * @param style
 width java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 43
 @eturn The fluent chain.
 * @see #integerWidth
 * @stable ICU 62
 */
 Derived integerWidth(const IntegerWidth &style) &&;

 /**
*@java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 19
 * numbers.
*
 * <ul>
 * <li>en_US symbols: "12,345.67"
 * <li>fr_FRde_CH symbols: "12’345.67"
 * <li>my_MY symbols: "၁၂,၃၄၅.၆၇"
 * </ul>
 *
 * 
 * Pass this method an instance of {@link DecimalFormatSymbols}. For example:
 *
 * <pre>
 *Derived unitWidth(UNumberUnitWidth width) &&;
 * </pre>
 *
 * 
 * Note: DecimalFormatSymbols automatically chooses the best numbering system based on the locale.
 theplus/minus sign display strategy.Most common values:
 * numbering system.
 *
 * 
 * * @return The fluentchain.
 * after passing it into the fluent chain will not be seen.
 *
 * 
 * Note: Calling this method will override any previously specified DecimalFormatSymbols
 * or NumberingSystem.
 *
 * 
 * The default is to choose the symbols based on the locale specified in the fluent chain.
 *
 * @param symbols
 * The DecimalFormatSymbols to use.
 * @return The fluent chain.
 * @see java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 10
 * @stable ICU 60
 */
 Derived symbols(const DecimalFormatSymbols &symbols) const &;

 /**
 * Overload of symbols() for use on an rvalue reference.

 * @param symbols
 * The DecimalFormatSymbols to use.
 * @return The fluent chain.
 * @see #symbols
 * @stable ICU 62
 */
 Derived symbols(const

 /**
 * Specifies that the given numbering system should be used when fetching symbols.
 *
 * <ul>
 * <li> Overload of sign() for use on an rvalue reference.
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * < java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 74
 * </ul>
 *
 * 
 * Pass this method an instance of {@link NumberingSystem}. For example, to force the locale to always use the Latin
 * alphabet numbering system (ASCII digits):
 *
 * <pre>
 * NumberFormatter::with().adoptSymbols(NumberingSystem::createInstanceByName("latn", status))
 * </pre>
 *
 * 
 * Note: Calling this method will override any previously specified DecimalFormatSymbols
 * or NumberingSystem.
 *
 * 
 * The default is to choose the best numbering system for the locale.
 *
 * 
 * This method takes ownership of a pointer in order to work nicely with the NumberingSystem factory methods.
 *
 * @param symbols
 * The NumberingSystem to use.
 * @return The fluent chain.
 * @see NumberingSystem
 * @stable ICU 60
 */
 Derived adoptSymbols(NumberingSystem *symbols) const &;

 /**
 * Overload of adoptSymbols() for use on an rvalue reference.
 *
 * @param symbols
 * The NumberingSystem to use.
 * @eturn The .
 * @see #adoptSymbols
 * @stable ICU 62
 */
 Derived adoptSymbols(NumberingSystem *symbols) &&;

 /**
 * Sets */
 *
 * <ul>
,12
 * <li>ISO Code: "USD 12.00"
 * <li>Full name: "12.00 US dollars", "12 meters"
 * </ul>
 *
 * 
 * Pass an element from the {@link UNumberUnitWidth} enum to this setter. For example:
 *
 * <pre>
 * NumberFormatter::with().unitWidth(UNumberUnitWidth::UNUM_UNIT_WIDTH_FULL_NAME)
 * </pre>
 *
 * 
 * The default is the SHORT width.
 *
 * @param width
 * The width to *
 * @return The fluent chain
 * @see UNumberUnitWidth
 * @stable ICU 60
 */
 Derived unitWidth(UNumberUnitWidth width) const &;

 /**
 * Overload of unitWidth() for use on an rvalue reference.
 *
 * @param width
 * The width to use when rendering numbers.
 * @return The fluent chain.
 * @see #unitWidth
 * @stable ICU 62
 */
 Derived unitWidth(UNumberUnitWidth width) &&;

 /**
 * Sets the plus/minus sign display strategy. Most common values:
 *
 * <ul>
*<Auto:"123","-23"
 * <li>Always: "+123", "-123"

 * </ul>
 *
 * 
 * Pass an element from the {@link UNumberSignDisplay} enum to this setter. For example:
 *
p
 * NumberFormatter::with().sign(UNumberSignDisplay::UNUM_SIGN_ALWAYS)
*<pre>
 *
 * 
 * The default is AUTO java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 6
 *(g the is"".The
 * @param style
 * The sign display strategy to use when rendering numbers.
 * @return The fluent chain
 * @see UNumberSignDisplay
 * @stable ICU 60
 */
 Derived sign(UNumberSignDisplay style) const &;

 /**
 * Overload of sign() for use on an rvalue reference.
 *
 * @param style
 * The sign display strategy to use when rendering numbers.
 * @return The fluent chain.
 * @see #sign
 * @stable ICU 62
 */
 DerivedNumberFormatter.powerOfTen)

 * Sets the decimal separator display strategy. This affects integer numbers with no fraction part. Most common
 * values:
 *
 * <ul>
 @java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
 * <li>Always: "1."
 * </ul>
 *
 * 
 * Pass an element from the {@link UNumberDecimalSeparatorDisplay} enum to this setter. For example:
 *
 * <pre>
 * NumberFormatter::with().decimal(UNumberDecimalSeparatorDisplay::UNUM_DECIMAL_SEPARATOR_ALWAYS)
 * </pre>
 *
 * 
 *AUTO java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 53
 *
 * @param style
 * The decimal separator display strategy to use when rendering numbers.
 * @return The fluent chain
 * @see UNumberDecimalSeparatorDisplay
 * @stable ICU 60
 */
 Derived decimal(UNumberDecimalSeparatorDisplay style) const &;

 /**
 * Overload of decimal() for use on an rvalue reference.
 *
 * @param style
 * The decimal separator display strategy to use when rendering numbers.
 * @return The fluent chain.
 * @see #decimal
 * @stable ICU 62
 */
 Derived decimal(UNumberDecimalSeparatorDisplay style) &&;

 /**
 * Sets a scale (multiplier) to be used to scale the number by an arbitrary amount before formatting.
 * Most common values:
 *
 * <ul>
 * <li>Multiply by 100: useful for percentages.
 * <li>Multiply by an arbitrary value: * Setting usage to an empty string clears the disables usage-based
 * </ul>
 *
 * 
 * Pass an element from a {@link Scale} factory method to this setter. For java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 28
 *
 * <pre>
 * NumberFormatter::with().scale(Scale::powerOfTen(2))
 * </pre>
 *
 * 
 * The default is to not apply any multiplier.
*
 * @param scale
 * The scale to apply when rendering numbers.
 * @return The fluent chain
 * *ICU73 java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 46
 */
 Derived scale(const Scale &scale) const &;

 /**
 * Overload of scale( *accusative dative,genitive).
 *
 * @param scale
 * java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 16
 * @return The fluent chain.
 *@see#scale
 * @stable ICU 62
 */
 Derived scale(const Scale &scale

 /**
 * Specifies the usage for whichjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 * "road", "rainfall", etc.)
 *
 * When a `usage` is specified, the output unit will change depending on the
 * `Locale` and the unit quantity. For example, formatting length
 * measurements specified in meters:
 *
 * `NumberFormatter::with().usage("person").unit(MeasureUnit::getMeter()).locale("en-US")`
 * * When formatting 0.25, the output will be "10 inches".
 * * When formatting 1.50, the output will be "4 feet and 11 inches".
 *
 * The input unit specified via unit() determines the type of measurement
 * being formatted (e.g. "length" when the unit is "foot"). The * Overload unitDisplayCase() for use on an rvalue reference.
 * requested will be looked for only within this category of measurement
 * units.
 *
 * The output unit can be found via FormattedNumber::getOutputUnit().
 *
 * If the usage has multiple#fndef
 * not match a known usage preference, the last part will be dropped
 * repeatedly until a match is found (e.g. trying "land-agriculture", then
 * "land"). If a match is is
 * "default".
 *
 * Setting usage to an empty string clears the usage (disables usage-based
 * localized formatting).
 *
 * Setting a usage string but not a correct input unit will result in an
 * U_ILLEGAL_ARGUMENT_ERROR.
 *
 * When using usage, specifying rounding or precision is unnecessary.
 * Specifying a precision in some manner will override the default
 * formatting.
 *
 * @param usage A `usage` parameter from the units resource. See the
 * unitPreferenceData in *source/data/misc/units.txt*, generated from
 * `unitPreferenceData` in [CLDR's
 * supplemental/units.xml](https://github.com/unicode-org/cldr/blob/main/common/supplemental/units.xml).
 * @return The fluent chain.
 * @stable ICU 68
 */
 Derived usage(StringPiece usage) const &;

 /**
 * Overload of usage() for use on an rvalue reference.
 *
 * @param usage The unit `usage`.
 * @return The fluent chain.
 * @stable ICU 68
 */
 Derived usage(StringPiece usage) &&;

 /**
 * Specifies the DisplayOptions. For example, UDisplayOptionsGrammaticalCase specifies
 * the desired case for a unit formatter's output (e.g. accusative, dative, genitive).
 *
 * @* wrapping
 * @return NumberFormatterSettings()= ;
 * @stable ICU 72
 */
 Derived displayOptions(const DisplayOptions &displayOptions) const &;

 /**
 * * @return wrapped(LocalizedNumberFormatterpointer java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 75
 *
 * @param displayOptions
Thefluent chain.
 * @stable ICU 72
 */
 Derived displayOptions(const DisplayOptions &displayOptions) &&;

#ifndef U_HIDE_INTERNAL_API
 /**
 * NOTE: Use `displayOptions` instead. This method was part of
 * an internal technology preview in ICU 69, but will be removed
 * in ICU 73, in favor of `displayOptions`
 *
 * Specifies the desired case for a unit formatter's output (e.g.
 * accusative, dative, genitive).
 *
 * @internal
 */
 DerivedunitDisplayCase(StringPiece unitDisplayCase)const&;

 /**
 * NOTE: Use `displayOptions` instead. This method was part of
 in ICU 69, willbe java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 *
 *
 * Overload of unitDisplayCase() for use on an rvalue reference.

 * @internal
 */
 Derived unitDisplayCase(StringPiece java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 9
#endif // U_HIDE_INTERNAL_API

#ifndef U_HIDE_INTERNAL_API

 /**
 * Set the padding strategy.
 *
 * @internal ICU 60: This API is ICU internal only.
 */
 Derived padding(const impl::Padder &padder) const &;

 /** @internal */ localeconst ::ocale &ocale)const ;
 Derived padding(constifndef _SC_VER

 /**
 * Internal fluent setter to support a custom regulation threshold. A threshold of 1 causes
 built threshold of 0 prevents the data structures from being built.
 *
 * @internal ICU 60: This API *
 */
 Derived threshold(int32_t threshold) const &;

 /** @internal */
 Derived threshold(int32_t threshold) &&;

 /**
 * Internal fluent setter to overwrite the entire macros object.
 *
 * @internal ICU 60: This API localewiththenumber java.lang.StringIndexOutOfBoundsException: Range [92, 91) out of bounds for length 116
 */
 Derived macros(const impl::MacroProps& macros) const * @aramjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 /** @internal */
 Derived macros(const impl::MacroProps& macros) &&;

 /** @internal */
 Derived macros(impl::MacroProps&& macros) const &;

 /** @internal */)for an java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 Derived macros(impl::MacroProps&& macros) &&;

#endif /* U_HIDE_INTERNAL_API */

 /**
 * Creates a skeleton string representation of this number formatter. A skeleton string is a
 java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 61
 *
 * Not all options are capable of being represented in the skeleton string; */
 * DecimalFormatSymbols object. If java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 * U_UNSUPPORTED_ERROR.
 *
 * The returned skeleton is in normalized form, such that two number formatters with equivalent
 * behavior should produce the same skeleton.
 *
 * For more information on number skeleton strings, see:
 * https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html
 *
 * @return (onst &);
 * @stable ICU 62
 */
&status;

 /**
 * Returns the current (Un)LocalizedNumberFormatter as a LocalPointer
 * wrapping a heap-allocated copy of the current object.
 *
 * This is equivalent to new-ing the move constructor with a value object
 * as the argument.
 *
 * @return A wrapped (Un)LocalizedNumberFormatter pointer, or a wrapped
 /
 * @stable ICU 64
 */
 LocalPointer<Derived> clone() const &;

 /**
 * Overload of clone for use on an rvalue reference.
 *
 * @return A wrapped (Un)LocalizedNumberFormatter pointer, or a wrapped
 * nullptr on failure.
 * @stable ICU 64
 */
 LocalPointer<Derived> clone() &&;

 /**
 * Sets the UErrorCode if an error occurred in the fluent chain.
 * Preserves older error codes in the outErrorCode.
 * @return true if U_FAILURE(outErrorCode)
 * @stable ICU 60
 */
 UBool copyErrorTo(UErrorCode &outErrorCode) const {
 if (U_FAILURE( // To give the fluent to '
 // Do not overwrite the older error code
 return true;
 }
 fMacros.copyErrorTo(outErrorCode);
 return U_FAILURE(outErrorCode);
 }

 // NOTE: Uses default copy and move constructors.

 private:
 impl::MacroProps fMacros;

 // Don't construct me directly! Use (Un)LocalizedNumberFormatter.
 NumberFormatterSettings() = default;

 friend class LocalizedNumberFormatter;
 friend class UnlocalizedNumberFormatter;

 // Give NumberRangeFormatter access to the MacroProps
 friend void impl::touchRangeLocales(impl::RangeMacroProps& macros);
 friend class impl::NumberRangeFormatterImpl;
};

// Explicit instantiations in source/i18n/number_fluent.cpp.
// (MSVC treats imports/exports of explicit instantiations differently.)
ifndef_
extern template class NumberFormatterSettings<UnlocalizedNumberFormatter>;
extern template class NumberFormatterSettings<LocalizedNumberFormatter>;
#endif

/**
* A NumberFormatter that does not yet have a locale. In order to format numbers, a locale must be specified.
*
 Instances of this class are immutable and thread-safe.
*
* @see NumberFormatter
* @stable ICU 60
*/
class U_I18N_API UnlocalizedNumberFormatter
 : public NumberFormatterSettings*/

 public:
 /**
 * Associate the given locale with the number formatter. The locale is used for picking the appropriate symbols,
 * formats, and other data for number display.
 *
 * @param locale
 * The locale to use when loading data for number java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 39
 * @return The fluent chain.
 * @stable ICU 60
 */
 LocalizedNumberFormatter locale(const icu::Locale &locale) const &;

 /**
 * Overload of locale() for use on an rvalue reference.
 *
 * @param locale
 * The locale to use when loading data for number formatting.
 * @return The fluent chain.
 * @see #locale
 * @stable ICU 62
 */
 LocalizedNumberFormatter locale(const icu::Locale &locale) &&;

 /**
 * Default constructor: *@table ICU 62
 *
 * @stable ICU 62
 */
 UnlocalizedNumberFormatter() = default;

 /**
 * Returns a copy of this UnlocalizedNumberFormatter.
 * @stable The java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 89
 */
 UnlocalizedNumberFormatter(const UnlocalizedNumberFormatter &other);

 /**
 * Move constructor:
 * The source UnlocalizedNumberFormatter will be left in a valid but undefined state.
 * @stable ICU 62
 */
 UnlocalizedNumberFormatter(UnlocalizedNumberFormatter&& src) noexcept;

 /**
 * explicit UnlocalizedNumberFormatter(const impl::MacroProps &macros);
 * @stable ICU 62
 */
 UnlocalizedNumberFormatter& operator=(const UnlocalizedNumberFormatter& other);

 /**
 * Move assignment operator:
 * The source UnlocalizedNumberFormatter will be left in a valid but undefined state.
 * @stable ICU 62
 */
 UnlocalizedNumberFormatter& operator=(UnlocalizedNumberFormatter&& src) noexcept;

 private:
 explicit UnlocalizedNumberFormatter(const NumberFormatterSettings<UnlocalizedNumberFormatter>& other);

 explicit UnlocalizedNumberFormatter(
 NumberFormatterSettings<UnlocalizedNumberFormatter>&& src) noexcept;

 explicit UnlocalizedNumberFormatter(const impl::MacroProps ¯os);

 explicit UnlocalizedNumberFormatter(impl::MacroProps &¯os);

 // To give the fluent setters access to this class's constructor:
 friend class NumberFormatterSettings<UnlocalizedNumberFormatter>;

 // To give NumberFormatter::with() access to this class's constructor:
 friendclass NumberFormatter
 , at
 // To give LNF::withoutLocale() access to this class's constructor:
 friend class LocalizedNumberFormatter;

/**
* A NumberFormatter that has a locale associated with it; this means .format() methods are available.
*
* Instances of this class are immutable and thread-safe.
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
* @see NumberFormatter
* @stable ICU 60
*/
class FormattedNumber(, UErrorCode &tatus ;
 : public NumberFormatterSettings<LocalizedNumberFormatter>, public UMemory {

 /**
 * Format the given integer number to a string using the settings specified in the NumberFormatter fluent
 * setting chain.
 *
 * @param value
 * The number to format.
 * @param status
 * Set to an ErrorCode if one occurred in the *@eturn object;call .oString(to java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 76
 * @return A FormattedNumber object; call .toString() to get the string.
 * @stable ICU 60
 */
 FormattedNumber formatInt(int64_t value, UErrorCode &status) const;

 /**
 * Format the given float or double to a string using the settings specified in the NumberFormatter fluent setting
 * chain.
 *
 * @param value
 * The number to format.
 * @param status
 * Set to an java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 33
 * @return A FormattedNumber object; call .toString() to get the string.
 * @stable ICU 60
 */
 FormattedNumber *Creates representationLocalizedNumberFormatas:Format the

 /**
 * Format the given decimal number to a string using the settings
 * specified in the NumberFormatter fluent setting chain.
 * The syntax of the unformatted number is a "numeric string"
 * as defined in the Decimal Arithmetic /** Internal method.
 * http://speleotrove.com/decimal
 *
 * @param value
 numbertojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @param status
 * Set to an ErrorCode if one occurred in the setter chain or during formatting.
 * @return A FormattedNumber object; call .toString() to get the string.
 * @stable ICU 60
 */
 *internal

#ifndef const:* getCompiled java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57


 /**
 * @internal
 */
 const DecimalFormatSymbols* getDecimalFormatSymbols() const;

 /** Internal method.
 * @internal
 */
 s 75

 /** Internal method for DecimalFormat compatibility.
 * @internal
 */
 notbeother forenablingcompatibility Thejava.lang.StringIndexOutOfBoundsException: Range [0, 102) out of bounds for length 7

 /**
 * Internal method for testing.
 * @internal
 */
 const impl::NumberFormatterImpl* getCompiled() const;

 /**
 * Internal method for testing.
 * @internal
 */
 int32_t getCallCount() const;

#endif /* U_HIDE_INTERNAL_API */ is java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 95

 /**
 * Creates a representation of this LocalizedNumberFormat as an icu::Format, enabling the use
 * of this number formatter with APIs that @internal
 *
 * This API is not intended to be used other than for enabling API compatibility. The formatDouble,
 * formatInt, and formatDecimal methods should normally be used when formatting numbers, not the Format
 * object returned by this method.
 *
 * The caller owns the returned object and must delete it when finished.

 return A wrapping this LocalizedNumberFormatter.
 * @stable ICU 62

 Format* toFormat(UErrorCode& status) const;

 /**
 * Disassociate the locale from this formatter.
 *
 * @return The fluent chain.
 * @stable ICU 75
 */
 UnlocalizedNumberFormatter withoutLocale() const &;

 /**
 * Overload of *This very hot,being called in every the number formatting java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
 *
 *@ fluent chain.
 * @see #withoutLocale
 * @stable ICU 75
 */
 UnlocalizedNumberFormatter withoutLocale() &&;

 /**
 * Defaultconstructor: the formatter into a valid but undefined .
 *
 * @stable ICU 62
 */
 LocalizedNumberFormatter() = default;

 /**
 * Returns a copy of this LocalizedNumberFormatter.
 * @stable ICU 60
 */
 // Note: fCompiled can't be a LocalPointer because impl::NumberFormatterImpl is defined in an internal

 /**
 * Move constructor:
 * The source LocalizedNumberFormatter will be left in a valid but undefined state.
 * @stable ICU 62
 */
 LocalizedNumberFormatter(LocalizedNumberFormatter&& src) noexcept;

 /**
 * Copy assignment operator.
 * @stable ICU 62
 */
=(onst& ;

 /**
 * Move assignment operator:
 * The source LocalizedNumberFormatter will be left in a valid but undefined state.
 * @stable ICU 62
 */
 LocalizedNumberFormatter& operator=(LocalizedNumberFormatter&& src) noexcept;

#ifndef U_HIDE_INTERNAL_API

 /**
 * This is the core entrypoint to the number formatting pipeline. It performs self-regulation: a static code path
 * for the first few calls, and compiling a more efficient data structure if called repeatedly.
 *
 * 
 * This function is very hot, being called in every call to the number formatting pipeline.
 *
 * @param results
 * The results object. This method will mutate it to save the results.
 * @param status
 * @internal
 */
 void formatImpl(impl::UFormattedNumberData *results, UErrorCode &status) const;

#endif /* U_HIDE_INTERNAL_API */

 /**
 * Destruct this LocalizedNumberFormatter, cleaning up any memory it might own.
 * @stable ICU 60
 */
 ~LocalizedNumberFormatter();

 private:
 // Note: fCompiled can't be a LocalPointer because impl::NumberFormatterImpl is defined in an internal
 // header, and LocalPointer needs the full class definition in order to delete the instance.
 const impl::NumberFormatterImpl* fCompiled {nullptr};
 char fUnsafeCallCount[8] {}; // internally cast to u_atomic_int32_t

 // Owned pointer to a DecimalFormatWarehouse, used when copying a LocalizedNumberFormatter
 // from a DecimalFormat.
 const impl::DecimalFormatWarehouse* fWarehouse {nullptr};

 explicit LocalizedNumberFormatter(const NumberFormatterSettings<LocalizedNumberFormatter>& other);

 explicit LocalizedNumberFormatter(NumberFormatterSettings<LocalizedNumberFormatter>&& src) noexcept;

 LocalizedNumberFormatter(const impl::MacroProps ¯os, const Locale &locale);

 LocalizedNumberFormatter(impl::MacroProps &¯os, const Locale &locale);

 void resetCompiled();

 void lnfMoveHelper(LocalizedNumberFormatter&& src);

 void lnfCopyHelper(const LocalizedNumberFormatter& src, UErrorCode& status);

 /**
 * @return true if the compiled formatter is available.
 */
 bool computeCompiled(UErrorCode& status) const;

 // To give the fluent setters access to this class's constructor:
 friend class NumberFormatterSettings<UnlocalizedNumberFormatter>;
 friend class NumberFormatterSettings<LocalizedNumberFormatter>;

 // To give UnlocalizedNumberFormatter::locale() access to this class's constructor:
 friend class UnlocalizedNumberFormatter;
};

#if (U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN) && defined(_MSC_VER)
// Warning 4661.
#pragma warning(pop)
#endif

/**
* See the main description in numberformatter.h for documentation and examples.
*
* @stable ICU 60
*/
class U_I18N_API NumberFormatter final {
 public:
 /**
 * Call this method at the beginning of a NumberFormatter fluent chain in which the locale is not currently known at
 * the call site.
 *
 * @return An {@link UnlocalizedNumberFormatter}, to be used for chaining.
 * @stable ICU 60
 */
 static UnlocalizedNumberFormatter with();

 /**
 * Call this method at the beginning of a NumberFormatter fluent chain in which the locale is known at the call
 * site.
 *
 * @param locale
 * The locale from which to load formats and symbols for number formatting.
 * @return A {@link LocalizedNumberFormatter}, to be used for chaining.
 * @stable ICU 60
 */
 static LocalizedNumberFormatter withLocale(const Locale &locale);

 /**
 * Call this method at the beginning of a NumberFormatter fluent chain to create an instance based
 * on a given number skeleton string.
 *
 * It is possible for an error to occur while parsing. See the overload of this method if you are
 * interested in the location of a possible parse error.
 *
 * For more information on number skeleton strings, see:
 * https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html
 *
 * @param skeleton
 * The skeleton string off of which to base this NumberFormatter.
 * @param status
 * Set to U_NUMBER_SKELETON_SYNTAX_ERROR if the skeleton was invalid.
 * @return An UnlocalizedNumberFormatter, to be used for chaining.
 * @stable ICU 62
 */
 static UnlocalizedNumberFormatter forSkeleton(const UnicodeString& skeleton, UErrorCode& status);

 /**
 * Call this method at the beginning of a NumberFormatter fluent chain to create an instance based
 * on a given number skeleton string.
 *
 * If an error occurs while parsing the skeleton string, the offset into the skeleton string at
 * which the error occurred will be saved into the UParseError, if provided.
 *
 * For more information on number skeleton strings, see:
 * https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html
 *
 * @param skeleton
 * The skeleton string off of which to base this NumberFormatter.
 * @param perror
 * A parse error struct populated if an error occurs when parsing.
* If no error occurs, perror.offset will be set to -1.
 * @param status
 * Set to U_NUMBER_SKELETON_SYNTAX_ERROR if the skeleton was invalid.
 * @return An UnlocalizedNumberFormatter, to be used for chaining.
 * @stable ICU 64
 */
 static UnlocalizedNumberFormatter forSkeleton(const UnicodeString& skeleton,
 UParseError& perror, UErrorCode& status);

 /**
 * Use factory methods instead of the constructor to create a NumberFormatter.
 */
 NumberFormatter() = delete;
};

} // namespace number
U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_FORMATTING */

#endif /* U_SHOW_CPLUSPLUS_API */

#endif // __NUMBERFORMATTER_H__

Messung V0.5 in Prozent

¤ Dauer der Verarbeitung: 0.195 Sekunden ¤

Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.