ICU 74.2  74.2
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 
583 public:
584 
585  //-----------------------------------------------------------------------
586  // constructors
587  //-----------------------------------------------------------------------
588 
599  RuleBasedNumberFormat(const UnicodeString& rules, UParseError& perror, UErrorCode& status);
600 
624  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
625  UParseError& perror, UErrorCode& status);
626 
642  RuleBasedNumberFormat(const UnicodeString& rules, const Locale& locale,
643  UParseError& perror, UErrorCode& status);
644 
671  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
672  const Locale& locale, UParseError& perror, UErrorCode& status);
673 
692  RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& locale, UErrorCode& status);
693 
694  //-----------------------------------------------------------------------
695  // boilerplate
696  //-----------------------------------------------------------------------
697 
704 
711 
716  virtual ~RuleBasedNumberFormat();
717 
724  virtual RuleBasedNumberFormat* clone() const override;
725 
733  virtual bool operator==(const Format& other) const override;
734 
735 //-----------------------------------------------------------------------
736 // public API functions
737 //-----------------------------------------------------------------------
738 
744  virtual UnicodeString getRules() const;
745 
751  virtual int32_t getNumberOfRuleSetNames() const;
752 
760  virtual UnicodeString getRuleSetName(int32_t index) const;
761 
767  virtual int32_t getNumberOfRuleSetDisplayNameLocales(void) const;
768 
777  virtual Locale getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const;
778 
792  virtual UnicodeString getRuleSetDisplayName(int32_t index,
793  const Locale& locale = Locale::getDefault());
794 
803  virtual UnicodeString getRuleSetDisplayName(const UnicodeString& ruleSetName,
804  const Locale& locale = Locale::getDefault());
805 
806 
807  using NumberFormat::format;
808 
817  virtual UnicodeString& format(int32_t number,
818  UnicodeString& toAppendTo,
819  FieldPosition& pos) const override;
820 
829  virtual UnicodeString& format(int64_t number,
830  UnicodeString& toAppendTo,
831  FieldPosition& pos) const override;
840  virtual UnicodeString& format(double number,
841  UnicodeString& toAppendTo,
842  FieldPosition& pos) const override;
843 
855  virtual UnicodeString& format(int32_t number,
856  const UnicodeString& ruleSetName,
857  UnicodeString& toAppendTo,
858  FieldPosition& pos,
859  UErrorCode& status) const;
871  virtual UnicodeString& format(int64_t number,
872  const UnicodeString& ruleSetName,
873  UnicodeString& toAppendTo,
874  FieldPosition& pos,
875  UErrorCode& status) const;
887  virtual UnicodeString& format(double number,
888  const UnicodeString& ruleSetName,
889  UnicodeString& toAppendTo,
890  FieldPosition& pos,
891  UErrorCode& status) const;
892 
893 protected:
911  virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
912  UnicodeString& appendTo,
913  FieldPosition& pos,
914  UErrorCode& status) const override;
915 public:
916 
917  using NumberFormat::parse;
918 
933  virtual void parse(const UnicodeString& text,
934  Formattable& result,
935  ParsePosition& parsePosition) const override;
936 
937 #if !UCONFIG_NO_COLLATION
938 
972  virtual void setLenient(UBool enabled) override;
973 
981  virtual inline UBool isLenient(void) const override;
982 
983 #endif
984 
993  virtual void setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status);
994 
1001  virtual UnicodeString getDefaultRuleSetName() const;
1002 
1013  virtual void setContext(UDisplayContext value, UErrorCode& status) override;
1014 
1020  virtual ERoundingMode getRoundingMode(void) const override;
1021 
1027  virtual void setRoundingMode(ERoundingMode roundingMode) override;
1028 
1029 public:
1035  static UClassID U_EXPORT2 getStaticClassID(void);
1036 
1042  virtual UClassID getDynamicClassID(void) const override;
1043 
1052  virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
1053 
1063  virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
1064 
1065 private:
1066  RuleBasedNumberFormat() = delete; // default constructor not implemented
1067 
1068  // this will ref the localizations if they are not nullptr
1069  // caller must deref to get adoption
1070  RuleBasedNumberFormat(const UnicodeString& description, LocalizationInfo* localizations,
1071  const Locale& locale, UParseError& perror, UErrorCode& status);
1072 
1073  void init(const UnicodeString& rules, LocalizationInfo* localizations, UParseError& perror, UErrorCode& status);
1074  void initCapitalizationContextInfo(const Locale& thelocale);
1075  void dispose();
1076  void stripWhitespace(UnicodeString& src);
1077  void initDefaultRuleSet();
1078  NFRuleSet* findRuleSet(const UnicodeString& name, UErrorCode& status) const;
1079 
1080  /* friend access */
1081  friend class NFSubstitution;
1082  friend class NFRule;
1083  friend class NFRuleSet;
1084  friend class FractionalPartSubstitution;
1085 
1086  inline NFRuleSet * getDefaultRuleSet() const;
1087  const RuleBasedCollator * getCollator() const;
1088  DecimalFormatSymbols * initializeDecimalFormatSymbols(UErrorCode &status);
1089  const DecimalFormatSymbols * getDecimalFormatSymbols() const;
1090  NFRule * initializeDefaultInfinityRule(UErrorCode &status);
1091  const NFRule * getDefaultInfinityRule() const;
1092  NFRule * initializeDefaultNaNRule(UErrorCode &status);
1093  const NFRule * getDefaultNaNRule() const;
1094  PluralFormat *createPluralFormat(UPluralType pluralType, const UnicodeString &pattern, UErrorCode& status) const;
1095  UnicodeString& adjustForCapitalizationContext(int32_t startPos, UnicodeString& currentResult, UErrorCode& status) const;
1096  UnicodeString& format(int64_t number, NFRuleSet *ruleSet, UnicodeString& toAppendTo, UErrorCode& status) const;
1097  void format(double number, NFRuleSet& rs, UnicodeString& toAppendTo, UErrorCode& status) const;
1098 
1099 private:
1100  NFRuleSet **fRuleSets;
1101  UnicodeString* ruleSetDescriptions;
1102  int32_t numRuleSets;
1103  NFRuleSet *defaultRuleSet;
1104  Locale locale;
1105  RuleBasedCollator* collator;
1106  DecimalFormatSymbols* decimalFormatSymbols;
1107  NFRule *defaultInfinityRule;
1108  NFRule *defaultNaNRule;
1109  ERoundingMode fRoundingMode;
1110  UBool lenient;
1111  UnicodeString* lenientParseRules;
1112  LocalizationInfo* localizations;
1113  UnicodeString originalDescription;
1114  UBool capitalizationInfoSet;
1115  UBool capitalizationForUIListMenu;
1116  UBool capitalizationForStandAlone;
1117  BreakIterator* capitalizationBrkIter;
1118 };
1119 
1120 // ---------------
1121 
1122 #if !UCONFIG_NO_COLLATION
1123 
1124 inline UBool
1125 RuleBasedNumberFormat::isLenient(void) const {
1126  return lenient;
1127 }
1128 
1129 #endif
1130 
1131 inline NFRuleSet*
1132 RuleBasedNumberFormat::getDefaultRuleSet() const {
1133  return defaultRuleSet;
1134 }
1135 
1136 U_NAMESPACE_END
1137 
1138 /* U_HAVE_RBNF */
1139 #endif
1140 
1141 #endif /* U_SHOW_CPLUSPLUS_API */
1142 
1143 /* RBNF_H */
1144 #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).
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:301
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
The BreakIterator class implements methods for finding the location of boundaries in text...
Definition: brkiter.h:106
C API: Plural rules, select plural keywords for numeric values.
virtual UClassID getDynamicClassID(void) const override=0
Returns a unique class ID POLYMORPHICALLY.
The RuleBasedNumberFormat class formats numbers according to a set of rules.
Definition: rbnf.h:582
virtual ERoundingMode getRoundingMode(void) const
Get the rounding mode.
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:415
static UClassID getStaticClassID(void)
Return the class ID for this class.
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:64
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.
virtual UBool isLenient(void) const
Returns whether lenient parsing is enabled (it is off by default).
Definition: numfmt.h:1276
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