ICU 64.1  64.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 
27 #if UCONFIG_NO_FORMATTING
28 #define U_HAVE_RBNF 0
29 #else
30 #define U_HAVE_RBNF 1
31 
32 #include "unicode/dcfmtsym.h"
33 #include "unicode/fmtable.h"
34 #include "unicode/locid.h"
35 #include "unicode/numfmt.h"
36 #include "unicode/unistr.h"
37 #include "unicode/strenum.h"
38 #include "unicode/brkiter.h"
39 #include "unicode/upluralrules.h"
40 
42 
43 class NFRule;
44 class NFRuleSet;
45 class LocalizationInfo;
46 class PluralFormat;
47 class RuleBasedCollator;
48 
55  URBNF_SPELLOUT,
56  URBNF_ORDINAL,
57  URBNF_DURATION,
58  URBNF_NUMBERING_SYSTEM,
59 #ifndef U_HIDE_DEPRECATED_API
60 
65 #endif // U_HIDE_DEPRECATED_API
66 };
67 
561 public:
562 
563  //-----------------------------------------------------------------------
564  // constructors
565  //-----------------------------------------------------------------------
566 
577  RuleBasedNumberFormat(const UnicodeString& rules, UParseError& perror, UErrorCode& status);
578 
602  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
603  UParseError& perror, UErrorCode& status);
604 
620  RuleBasedNumberFormat(const UnicodeString& rules, const Locale& locale,
621  UParseError& perror, UErrorCode& status);
622 
649  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
650  const Locale& locale, UParseError& perror, UErrorCode& status);
651 
667  RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& locale, UErrorCode& status);
668 
669  //-----------------------------------------------------------------------
670  // boilerplate
671  //-----------------------------------------------------------------------
672 
679 
686 
691  virtual ~RuleBasedNumberFormat();
692 
699  virtual Format* clone(void) const;
700 
708  virtual UBool operator==(const Format& other) const;
709 
710 //-----------------------------------------------------------------------
711 // public API functions
712 //-----------------------------------------------------------------------
713 
719  virtual UnicodeString getRules() const;
720 
726  virtual int32_t getNumberOfRuleSetNames() const;
727 
735  virtual UnicodeString getRuleSetName(int32_t index) const;
736 
742  virtual int32_t getNumberOfRuleSetDisplayNameLocales(void) const;
743 
752  virtual Locale getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const;
753 
767  virtual UnicodeString getRuleSetDisplayName(int32_t index,
768  const Locale& locale = Locale::getDefault());
769 
778  virtual UnicodeString getRuleSetDisplayName(const UnicodeString& ruleSetName,
779  const Locale& locale = Locale::getDefault());
780 
781 
782  using NumberFormat::format;
783 
792  virtual UnicodeString& format(int32_t number,
793  UnicodeString& toAppendTo,
794  FieldPosition& pos) const;
795 
804  virtual UnicodeString& format(int64_t number,
805  UnicodeString& toAppendTo,
806  FieldPosition& pos) const;
815  virtual UnicodeString& format(double number,
816  UnicodeString& toAppendTo,
817  FieldPosition& pos) const;
818 
830  virtual UnicodeString& format(int32_t number,
831  const UnicodeString& ruleSetName,
832  UnicodeString& toAppendTo,
833  FieldPosition& pos,
834  UErrorCode& status) const;
846  virtual UnicodeString& format(int64_t number,
847  const UnicodeString& ruleSetName,
848  UnicodeString& toAppendTo,
849  FieldPosition& pos,
850  UErrorCode& status) const;
862  virtual UnicodeString& format(double number,
863  const UnicodeString& ruleSetName,
864  UnicodeString& toAppendTo,
865  FieldPosition& pos,
866  UErrorCode& status) const;
867 
868 protected:
886  virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
887  UnicodeString& appendTo,
888  FieldPositionIterator* posIter,
889  UErrorCode& status) const;
890 
908  virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
909  UnicodeString& appendTo,
910  FieldPosition& pos,
911  UErrorCode& status) const;
912 public:
913 
914  using NumberFormat::parse;
915 
930  virtual void parse(const UnicodeString& text,
931  Formattable& result,
932  ParsePosition& parsePosition) const;
933 
934 #if !UCONFIG_NO_COLLATION
935 
969  virtual void setLenient(UBool enabled);
970 
978  virtual inline UBool isLenient(void) const;
979 
980 #endif
981 
990  virtual void setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status);
991 
998  virtual UnicodeString getDefaultRuleSetName() const;
999 
1010  virtual void setContext(UDisplayContext value, UErrorCode& status);
1011 
1017  virtual ERoundingMode getRoundingMode(void) const;
1018 
1024  virtual void setRoundingMode(ERoundingMode roundingMode);
1025 
1026 public:
1032  static UClassID U_EXPORT2 getStaticClassID(void);
1033 
1039  virtual UClassID getDynamicClassID(void) const;
1040 
1049  virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
1050 
1060  virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
1061 
1062 private:
1063  RuleBasedNumberFormat(); // default constructor not implemented
1064 
1065  // this will ref the localizations if they are not NULL
1066  // caller must deref to get adoption
1067  RuleBasedNumberFormat(const UnicodeString& description, LocalizationInfo* localizations,
1068  const Locale& locale, UParseError& perror, UErrorCode& status);
1069 
1070  void init(const UnicodeString& rules, LocalizationInfo* localizations, UParseError& perror, UErrorCode& status);
1071  void initCapitalizationContextInfo(const Locale& thelocale);
1072  void dispose();
1073  void stripWhitespace(UnicodeString& src);
1074  void initDefaultRuleSet();
1075  NFRuleSet* findRuleSet(const UnicodeString& name, UErrorCode& status) const;
1076 
1077  /* friend access */
1078  friend class NFSubstitution;
1079  friend class NFRule;
1080  friend class NFRuleSet;
1081  friend class FractionalPartSubstitution;
1082 
1083  inline NFRuleSet * getDefaultRuleSet() const;
1084  const RuleBasedCollator * getCollator() const;
1085  DecimalFormatSymbols * initializeDecimalFormatSymbols(UErrorCode &status);
1086  const DecimalFormatSymbols * getDecimalFormatSymbols() const;
1087  NFRule * initializeDefaultInfinityRule(UErrorCode &status);
1088  const NFRule * getDefaultInfinityRule() const;
1089  NFRule * initializeDefaultNaNRule(UErrorCode &status);
1090  const NFRule * getDefaultNaNRule() const;
1091  PluralFormat *createPluralFormat(UPluralType pluralType, const UnicodeString &pattern, UErrorCode& status) const;
1092  UnicodeString& adjustForCapitalizationContext(int32_t startPos, UnicodeString& currentResult, UErrorCode& status) const;
1093  UnicodeString& format(int64_t number, NFRuleSet *ruleSet, UnicodeString& toAppendTo, UErrorCode& status) const;
1094  void format(double number, NFRuleSet& rs, UnicodeString& toAppendTo, UErrorCode& status) const;
1095 
1096 private:
1097  NFRuleSet **fRuleSets;
1098  UnicodeString* ruleSetDescriptions;
1099  int32_t numRuleSets;
1100  NFRuleSet *defaultRuleSet;
1101  Locale locale;
1102  RuleBasedCollator* collator;
1103  DecimalFormatSymbols* decimalFormatSymbols;
1104  NFRule *defaultInfinityRule;
1105  NFRule *defaultNaNRule;
1106  ERoundingMode fRoundingMode;
1107  UBool lenient;
1108  UnicodeString* lenientParseRules;
1109  LocalizationInfo* localizations;
1110  UnicodeString originalDescription;
1111  UBool capitalizationInfoSet;
1112  UBool capitalizationForUIListMenu;
1113  UBool capitalizationForStandAlone;
1114  BreakIterator* capitalizationBrkIter;
1115 };
1116 
1117 // ---------------
1118 
1119 #if !UCONFIG_NO_COLLATION
1120 
1121 inline UBool
1123  return lenient;
1124 }
1125 
1126 #endif
1127 
1128 inline NFRuleSet*
1129 RuleBasedNumberFormat::getDefaultRuleSet() const {
1130  return defaultRuleSet;
1131 }
1132 
1134 
1135 /* U_HAVE_RBNF */
1136 #endif
1137 
1138 /* RBNF_H */
1139 #endif
C++ API: Break Iterator.
Base class for all formats.
Definition: format.h:96
virtual ERoundingMode getRoundingMode(void) const
Get the rounding mode.
This class represents the set of symbols needed by DecimalFormat to format numbers.
Definition: dcfmtsym.h:84
virtual UClassID getDynamicClassID(void) const =0
Returns a unique class ID 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:93
virtual Format * clone() const =0
Clone this object polymorphically.
virtual void setLenient(UBool enable)
Sets whether lenient parsing should be enabled (it is off by default).
virtual UBool isLenient(void) const
Returns whether lenient parsing is enabled (it is off by default).
Definition: numfmt.h:1249
#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:54
One more than the highest normal URBNFRuleSetTag value.
Definition: rbnf.h:64
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:137
The RuleBasedCollator class provides the implementation of Collator, using data-driven tables...
Definition: tblcoll.h:113
FieldPositionIterator returns the field ids and their start/limit positions generated by a call to Fo...
Definition: fpositer.h:55
The BreakIterator class implements methods for finding the location of boundaries in text...
Definition: brkiter.h:102
C API: Plural rules, select plural keywords for numeric values.
The RuleBasedNumberFormat class formats numbers according to a set of rules.
Definition: rbnf.h:560
virtual UBool operator==(const Format &other) const
Return true if the given Format objects are semantically equal.
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:138
virtual void setContext(UDisplayContext value, UErrorCode &status)
Set a particular UDisplayContext value in the formatter, such as UDISPCTX_CAPITALIZATION_FOR_STANDALO...
virtual UBool isLenient(void) const
Returns true if lenient-parse mode is turned on.
Definition: rbnf.h:1122
UErrorCode
Error code to replace exception handling, so that the code is compatible with all C++ compilers...
Definition: utypes.h:401
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:108
UPluralType
Type of plurals and PluralRules.
Definition: upluralrules.h:53
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:49
C++ API: Locale ID object.
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:289
Formattable objects can be passed to the Format class or its subclasses for formatting.
Definition: fmtable.h:62
virtual UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const
Format an object to produce a string.
C++ API: Compatibility APIs for number formatting.
NumberFormat & operator=(const NumberFormat &)
Assignment operator.
int8_t UBool
The ICU boolean type.
Definition: umachine.h:225
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:192