ICU 76.1  76.1
rbnf.h
Go to the documentation of this file.
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 * Copyright (C) 1997-2015, International Business Machines Corporation and others.
6 * All Rights Reserved.
7 *******************************************************************************
8 */
9 
10 #ifndef RBNF_H
11 #define RBNF_H
12 
13 #include "unicode/utypes.h"
14 
15 #if U_SHOW_CPLUSPLUS_API
16 
29 #if UCONFIG_NO_FORMATTING
30 #define U_HAVE_RBNF 0
31 #else
32 #define U_HAVE_RBNF 1
33 
34 #include "unicode/dcfmtsym.h"
35 #include "unicode/fmtable.h"
36 #include "unicode/locid.h"
37 #include "unicode/numfmt.h"
38 #include "unicode/unistr.h"
39 #include "unicode/strenum.h"
40 #include "unicode/brkiter.h"
41 #include "unicode/upluralrules.h"
42 
43 U_NAMESPACE_BEGIN
44 
45 class NFRule;
46 class NFRuleSet;
47 class LocalizationInfo;
48 class PluralFormat;
49 class RuleBasedCollator;
50 
67 #ifndef U_HIDE_DEPRECATED_API
68 
73 #endif // U_HIDE_DERECATED_API
74 
81 #ifndef U_HIDE_DEPRECATED_API
82 
87 #endif // U_HIDE_DEPRECATED_API
88 };
89 
592 public:
593 
594  //-----------------------------------------------------------------------
595  // constructors
596  //-----------------------------------------------------------------------
597 
608  RuleBasedNumberFormat(const UnicodeString& rules, UParseError& perror, UErrorCode& status);
609 
633  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
634  UParseError& perror, UErrorCode& status);
635 
651  RuleBasedNumberFormat(const UnicodeString& rules, const Locale& locale,
652  UParseError& perror, UErrorCode& status);
653 
680  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
681  const Locale& locale, UParseError& perror, UErrorCode& status);
682 
701  RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& locale, UErrorCode& status);
702 
703  //-----------------------------------------------------------------------
704  // boilerplate
705  //-----------------------------------------------------------------------
706 
713 
720 
725  virtual ~RuleBasedNumberFormat();
726 
733  virtual RuleBasedNumberFormat* clone() const override;
734 
742  virtual bool operator==(const Format& other) const override;
743 
744 //-----------------------------------------------------------------------
745 // public API functions
746 //-----------------------------------------------------------------------
747 
753  virtual UnicodeString getRules() const;
754 
760  virtual int32_t getNumberOfRuleSetNames() const;
761 
769  virtual UnicodeString getRuleSetName(int32_t index) const;
770 
776  virtual int32_t getNumberOfRuleSetDisplayNameLocales() const;
777 
786  virtual Locale getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const;
787 
801  virtual UnicodeString getRuleSetDisplayName(int32_t index,
802  const Locale& locale = Locale::getDefault());
803 
812  virtual UnicodeString getRuleSetDisplayName(const UnicodeString& ruleSetName,
813  const Locale& locale = Locale::getDefault());
814 
815 
816  using NumberFormat::format;
817 
826  virtual UnicodeString& format(int32_t number,
827  UnicodeString& toAppendTo,
828  FieldPosition& pos) const override;
829 
838  virtual UnicodeString& format(int64_t number,
839  UnicodeString& toAppendTo,
840  FieldPosition& pos) const override;
849  virtual UnicodeString& format(double number,
850  UnicodeString& toAppendTo,
851  FieldPosition& pos) const override;
852 
864  virtual UnicodeString& format(int32_t number,
865  const UnicodeString& ruleSetName,
866  UnicodeString& toAppendTo,
867  FieldPosition& pos,
868  UErrorCode& status) const;
880  virtual UnicodeString& format(int64_t number,
881  const UnicodeString& ruleSetName,
882  UnicodeString& toAppendTo,
883  FieldPosition& pos,
884  UErrorCode& status) const;
896  virtual UnicodeString& format(double number,
897  const UnicodeString& ruleSetName,
898  UnicodeString& toAppendTo,
899  FieldPosition& pos,
900  UErrorCode& status) const;
901 
902 protected:
920  virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
921  UnicodeString& appendTo,
922  FieldPosition& pos,
923  UErrorCode& status) const override;
924 public:
925 
926  using NumberFormat::parse;
927 
942  virtual void parse(const UnicodeString& text,
943  Formattable& result,
944  ParsePosition& parsePosition) const override;
945 
946 #if !UCONFIG_NO_COLLATION
947 
981  virtual void setLenient(UBool enabled) override;
982 
990  virtual inline UBool isLenient() const override;
991 
992 #endif
993 
1002  virtual void setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status);
1003 
1010  virtual UnicodeString getDefaultRuleSetName() const;
1011 
1022  virtual void setContext(UDisplayContext value, UErrorCode& status) override;
1023 
1029  virtual ERoundingMode getRoundingMode() const override;
1030 
1036  virtual void setRoundingMode(ERoundingMode roundingMode) override;
1037 
1038 public:
1044  static UClassID U_EXPORT2 getStaticClassID();
1045 
1051  virtual UClassID getDynamicClassID() const override;
1052 
1061  virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
1062 
1072  virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
1073 
1074 private:
1075  RuleBasedNumberFormat() = delete; // default constructor not implemented
1076 
1077  // this will ref the localizations if they are not nullptr
1078  // caller must deref to get adoption
1079  RuleBasedNumberFormat(const UnicodeString& description, LocalizationInfo* localizations,
1080  const Locale& locale, UParseError& perror, UErrorCode& status);
1081 
1082  void init(const UnicodeString& rules, LocalizationInfo* localizations, UParseError& perror, UErrorCode& status);
1083  void initCapitalizationContextInfo(const Locale& thelocale);
1084  void dispose();
1085  void stripWhitespace(UnicodeString& src);
1086  void initDefaultRuleSet();
1087  NFRuleSet* findRuleSet(const UnicodeString& name, UErrorCode& status) const;
1088 
1089  /* friend access */
1090  friend class NFSubstitution;
1091  friend class NFRule;
1092  friend class NFRuleSet;
1093  friend class FractionalPartSubstitution;
1094 
1095  inline NFRuleSet * getDefaultRuleSet() const;
1096  const RuleBasedCollator * getCollator() const;
1097  DecimalFormatSymbols * initializeDecimalFormatSymbols(UErrorCode &status);
1098  const DecimalFormatSymbols * getDecimalFormatSymbols() const;
1099  NFRule * initializeDefaultInfinityRule(UErrorCode &status);
1100  const NFRule * getDefaultInfinityRule() const;
1101  NFRule * initializeDefaultNaNRule(UErrorCode &status);
1102  const NFRule * getDefaultNaNRule() const;
1103  PluralFormat *createPluralFormat(UPluralType pluralType, const UnicodeString &pattern, UErrorCode& status) const;
1104  UnicodeString& adjustForCapitalizationContext(int32_t startPos, UnicodeString& currentResult, UErrorCode& status) const;
1105  UnicodeString& format(int64_t number, NFRuleSet *ruleSet, UnicodeString& toAppendTo, UErrorCode& status) const;
1106  void format(double number, NFRuleSet& rs, UnicodeString& toAppendTo, UErrorCode& status) const;
1107 
1108 private:
1109  NFRuleSet **fRuleSets;
1110  UnicodeString* ruleSetDescriptions;
1111  int32_t numRuleSets;
1112  NFRuleSet *defaultRuleSet;
1113  Locale locale;
1114  RuleBasedCollator* collator;
1115  DecimalFormatSymbols* decimalFormatSymbols;
1116  NFRule *defaultInfinityRule;
1117  NFRule *defaultNaNRule;
1118  ERoundingMode fRoundingMode;
1119  UBool lenient;
1120  UnicodeString* lenientParseRules;
1121  LocalizationInfo* localizations;
1122  UnicodeString originalDescription;
1123  UBool capitalizationInfoSet;
1124  UBool capitalizationForUIListMenu;
1125  UBool capitalizationForStandAlone;
1126  BreakIterator* capitalizationBrkIter;
1127 };
1128 
1129 // ---------------
1130 
1131 #if !UCONFIG_NO_COLLATION
1132 
1133 inline UBool
1134 RuleBasedNumberFormat::isLenient() const {
1135  return lenient;
1136 }
1137 
1138 #endif
1139 
1140 inline NFRuleSet*
1141 RuleBasedNumberFormat::getDefaultRuleSet() const {
1142  return defaultRuleSet;
1143 }
1144 
1145 U_NAMESPACE_END
1146 
1147 /* U_HAVE_RBNF */
1148 #endif
1149 
1150 #endif /* U_SHOW_CPLUSPLUS_API */
1151 
1152 /* RBNF_H */
1153 #endif
C++ API: Break Iterator.
Base class for all formats.
Definition: format.h:98
This class represents the set of symbols needed by DecimalFormat to format numbers.
Definition: dcfmtsym.h:86
virtual NumberFormat * clone() const override=0
Clones this object polymorphically.
virtual void parse(const UnicodeString &text, Formattable &result, ParsePosition &parsePosition) const =0
Return a long if possible (e.g.
UDisplayContext
Display context settings.
C++ API: Unicode String.
virtual void setRoundingMode(ERoundingMode roundingMode)
Set the rounding mode.
void * UClassID
UClassID is used to identify classes without using the compiler's RTTI.
Definition: uobject.h:96
virtual void setLenient(UBool enable)
Sets whether lenient parsing should be enabled (it is off by default).
static UClassID getStaticClassID()
Return the class ID for this class.
Requests predefined ruleset for various non-place-value numbering systems.
Definition: rbnf.h:80
virtual bool operator==(const Format &other) const override
Return true if the given Format objects are semantically equal.
#define U_I18N_API
Set to export library symbols from inside the i18n library, and to import them from outside...
Definition: utypes.h:316
URBNFRuleSetTag
Tags for the predefined rulesets.
Definition: rbnf.h:56
One more than the highest normal URBNFRuleSetTag value.
Definition: rbnf.h:86
virtual UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const override
Format an object to produce a string.
The RuleBasedCollator class provides the implementation of Collator, using data-driven tables...
Definition: tblcoll.h:115
virtual UClassID getDynamicClassID() const override=0
Returns a unique class ID POLYMORPHICALLY.
The BreakIterator class implements methods for finding the location of boundaries in text...
Definition: brkiter.h:106
virtual ERoundingMode getRoundingMode() const
Get the rounding mode.
C API: Plural rules, select plural keywords for numeric values.
The RuleBasedNumberFormat class formats numbers according to a set of rules.
Definition: rbnf.h:591
virtual void setContext(UDisplayContext value, UErrorCode &status)
Set a particular UDisplayContext value in the formatter, such as UDISPCTX_CAPITALIZATION_FOR_STANDALO...
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
Definition: utypes.h:430
FieldPosition is a simple class used by Format and its subclasses to identify fields in formatted out...
Definition: fieldpos.h:110
UPluralType
Type of plurals and PluralRules.
Definition: upluralrules.h:59
C++ API: Symbols for formatting numbers.
C++ API: String Enumeration.
ParsePosition is a simple class used by Format and its subclasses to keep track of the current positi...
Definition: parsepos.h:52
C++ API: Locale ID object.
Requests predefined ruleset for spelling out numeric values in words.
Definition: rbnf.h:61
Requests predefined ruleset for formatting a value as a duration in hours, minutes, and seconds.
Definition: rbnf.h:72
A UParseError struct is used to returned detailed information about parsing errors.
Definition: parseerr.h:58
Basic definitions for ICU, for both C and C++ APIs.
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:295
Formattable objects can be passed to the Format class or its subclasses for formatting.
Definition: fmtable.h:63
virtual UBool isLenient() const
Returns whether lenient parsing is enabled (it is off by default).
Definition: numfmt.h:1274
C++ API: Compatibility APIs for number formatting.
Requests predefined ruleset for the ordinal form of a number.
Definition: rbnf.h:66
NumberFormat & operator=(const NumberFormat &)
Assignment operator.
int8_t UBool
The ICU boolean type, a signed-byte integer.
Definition: umachine.h:247
C++ API: Formattable is a thin wrapper for primitive types used for formatting and parsing...
A Locale object represents a specific geographical, political, or cultural region.
Definition: locid.h:195