ICU 58.2  58.2
rbnf.h
Go to the documentation of this file.
1 // Copyright (C) 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 
562 public:
563 
564  //-----------------------------------------------------------------------
565  // constructors
566  //-----------------------------------------------------------------------
567 
578  RuleBasedNumberFormat(const UnicodeString& rules, UParseError& perror, UErrorCode& status);
579 
603  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
604  UParseError& perror, UErrorCode& status);
605 
621  RuleBasedNumberFormat(const UnicodeString& rules, const Locale& locale,
622  UParseError& perror, UErrorCode& status);
623 
650  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
651  const Locale& locale, UParseError& perror, UErrorCode& status);
652 
668  RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& locale, UErrorCode& status);
669 
670  //-----------------------------------------------------------------------
671  // boilerplate
672  //-----------------------------------------------------------------------
673 
680 
687 
692  virtual ~RuleBasedNumberFormat();
693 
700  virtual Format* clone(void) const;
701 
709  virtual UBool operator==(const Format& other) const;
710 
711 //-----------------------------------------------------------------------
712 // public API functions
713 //-----------------------------------------------------------------------
714 
720  virtual UnicodeString getRules() const;
721 
727  virtual int32_t getNumberOfRuleSetNames() const;
728 
736  virtual UnicodeString getRuleSetName(int32_t index) const;
737 
743  virtual int32_t getNumberOfRuleSetDisplayNameLocales(void) const;
744 
753  virtual Locale getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const;
754 
768  virtual UnicodeString getRuleSetDisplayName(int32_t index,
769  const Locale& locale = Locale::getDefault());
770 
779  virtual UnicodeString getRuleSetDisplayName(const UnicodeString& ruleSetName,
780  const Locale& locale = Locale::getDefault());
781 
782 
783  using NumberFormat::format;
784 
793  virtual UnicodeString& format(int32_t number,
794  UnicodeString& toAppendTo,
795  FieldPosition& pos) const;
796 
805  virtual UnicodeString& format(int64_t number,
806  UnicodeString& toAppendTo,
807  FieldPosition& pos) const;
816  virtual UnicodeString& format(double number,
817  UnicodeString& toAppendTo,
818  FieldPosition& pos) const;
819 
831  virtual UnicodeString& format(int32_t number,
832  const UnicodeString& ruleSetName,
833  UnicodeString& toAppendTo,
834  FieldPosition& pos,
835  UErrorCode& status) const;
847  virtual UnicodeString& format(int64_t number,
848  const UnicodeString& ruleSetName,
849  UnicodeString& toAppendTo,
850  FieldPosition& pos,
851  UErrorCode& status) const;
863  virtual UnicodeString& format(double number,
864  const UnicodeString& ruleSetName,
865  UnicodeString& toAppendTo,
866  FieldPosition& pos,
867  UErrorCode& status) const;
868 
869  using NumberFormat::parse;
870 
885  virtual void parse(const UnicodeString& text,
886  Formattable& result,
887  ParsePosition& parsePosition) const;
888 
889 #if !UCONFIG_NO_COLLATION
890 
924  virtual void setLenient(UBool enabled);
925 
933  virtual inline UBool isLenient(void) const;
934 
935 #endif
936 
945  virtual void setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status);
946 
953  virtual UnicodeString getDefaultRuleSetName() const;
954 
965  virtual void setContext(UDisplayContext value, UErrorCode& status);
966 
967 public:
973  static UClassID U_EXPORT2 getStaticClassID(void);
974 
980  virtual UClassID getDynamicClassID(void) const;
981 
990  virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
991 
1001  virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
1002 
1003 private:
1004  RuleBasedNumberFormat(); // default constructor not implemented
1005 
1006  // this will ref the localizations if they are not NULL
1007  // caller must deref to get adoption
1008  RuleBasedNumberFormat(const UnicodeString& description, LocalizationInfo* localizations,
1009  const Locale& locale, UParseError& perror, UErrorCode& status);
1010 
1011  void init(const UnicodeString& rules, LocalizationInfo* localizations, UParseError& perror, UErrorCode& status);
1012  void initCapitalizationContextInfo(const Locale& thelocale);
1013  void dispose();
1014  void stripWhitespace(UnicodeString& src);
1015  void initDefaultRuleSet();
1016  void format(double number, NFRuleSet& ruleSet);
1017  NFRuleSet* findRuleSet(const UnicodeString& name, UErrorCode& status) const;
1018 
1019  /* friend access */
1020  friend class NFSubstitution;
1021  friend class NFRule;
1022  friend class NFRuleSet;
1023  friend class FractionalPartSubstitution;
1024 
1025  inline NFRuleSet * getDefaultRuleSet() const;
1026  const RuleBasedCollator * getCollator() const;
1027  DecimalFormatSymbols * initializeDecimalFormatSymbols(UErrorCode &status);
1028  const DecimalFormatSymbols * getDecimalFormatSymbols() const;
1029  NFRule * initializeDefaultInfinityRule(UErrorCode &status);
1030  const NFRule * getDefaultInfinityRule() const;
1031  NFRule * initializeDefaultNaNRule(UErrorCode &status);
1032  const NFRule * getDefaultNaNRule() const;
1033  PluralFormat *createPluralFormat(UPluralType pluralType, const UnicodeString &pattern, UErrorCode& status) const;
1034  UnicodeString& adjustForCapitalizationContext(int32_t startPos, UnicodeString& currentResult) const;
1035 
1036 private:
1037  NFRuleSet **ruleSets;
1038  UnicodeString* ruleSetDescriptions;
1039  int32_t numRuleSets;
1040  NFRuleSet *defaultRuleSet;
1041  Locale locale;
1042  RuleBasedCollator* collator;
1043  DecimalFormatSymbols* decimalFormatSymbols;
1044  NFRule *defaultInfinityRule;
1045  NFRule *defaultNaNRule;
1046  UBool lenient;
1047  UnicodeString* lenientParseRules;
1048  LocalizationInfo* localizations;
1049  UnicodeString originalDescription;
1050  UBool capitalizationInfoSet;
1051  UBool capitalizationForUIListMenu;
1052  UBool capitalizationForStandAlone;
1053  BreakIterator* capitalizationBrkIter;
1054 };
1055 
1056 // ---------------
1057 
1058 #if !UCONFIG_NO_COLLATION
1059 
1060 inline UBool
1062  return lenient;
1063 }
1064 
1065 #endif
1066 
1067 inline NFRuleSet*
1068 RuleBasedNumberFormat::getDefaultRuleSet() const {
1069  return defaultRuleSet;
1070 }
1071 
1073 
1074 /* U_HAVE_RBNF */
1075 #endif
1076 
1077 /* RBNF_H */
1078 #endif
C++ API: Break Iterator.
Base class for all formats.
Definition: format.h:96
This class represents the set of symbols needed by DecimalFormat to format numbers.
Definition: dcfmtsym.h:86
virtual UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const
Format an object to produce a string.
virtual UClassID getDynamicClassID(void) const =0
Returns a unique class ID POLYMORPHICALLY.
Abstract base class for all number formats.
Definition: numfmt.h:169
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.
void * UClassID
UClassID is used to identify classes without using the compiler's RTTI.
Definition: uobject.h:93
virtual UBool isLenient(void) const
Returns true if lenient-parse mode is turned on.
Definition: rbnf.h:1061
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).
#define U_I18N_API
Set to export library symbols from inside the i18n library, and to import them from outside...
Definition: utypes.h:360
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:131
The RuleBasedCollator class provides the implementation of Collator, using data-driven tables...
Definition: tblcoll.h:113
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:561
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:132
virtual void setContext(UDisplayContext value, UErrorCode &status)
Set a particular UDisplayContext value in the formatter, such as UDISPCTX_CAPITALIZATION_FOR_STANDALO...
UErrorCode
Error code to replace exception handling, so that the code is compatible with all C++ compilers...
Definition: utypes.h:396
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:46
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.
virtual UBool operator==(const Format &other) const
Return true if the given Format objects are semantically equal.
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:68
C++ API: Abstract base class for all number formats.
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:1170
int8_t UBool
The ICU boolean type.
Definition: umachine.h:259
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:187