"Fossies" - the Fresh Open Source Software Archive

Member "rbnf_8h_source.html" (3 Oct 2019, 64238 Bytes) of package /linux/misc/icu4c-65_1-docs.zip:


Caution: In this restricted "Fossies" environment the current HTML page may not be correctly presentated and may have some non-functional links. You can here alternatively try to browse the pure source code or just view or download the uninterpreted raw source code. If the rendering is insufficient you may try to find and view the page on the project site itself.

ICU 65.1  65.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 
57  URBNF_SPELLOUT,
58  URBNF_ORDINAL,
59  URBNF_DURATION,
60  URBNF_NUMBERING_SYSTEM,
61 #ifndef U_HIDE_DEPRECATED_API
62 
67 #endif // U_HIDE_DEPRECATED_API
68 };
69 
563 public:
564 
565  //-----------------------------------------------------------------------
566  // constructors
567  //-----------------------------------------------------------------------
568 
579  RuleBasedNumberFormat(const UnicodeString& rules, UParseError& perror, UErrorCode& status);
580 
604  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
605  UParseError& perror, UErrorCode& status);
606 
622  RuleBasedNumberFormat(const UnicodeString& rules, const Locale& locale,
623  UParseError& perror, UErrorCode& status);
624 
651  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
652  const Locale& locale, UParseError& perror, UErrorCode& status);
653 
669  RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& locale, UErrorCode& status);
670 
671  //-----------------------------------------------------------------------
672  // boilerplate
673  //-----------------------------------------------------------------------
674 
681 
688 
693  virtual ~RuleBasedNumberFormat();
694 
701  virtual RuleBasedNumberFormat* clone() const;
702 
710  virtual UBool operator==(const Format& other) const;
711 
712 //-----------------------------------------------------------------------
713 // public API functions
714 //-----------------------------------------------------------------------
715 
721  virtual UnicodeString getRules() const;
722 
728  virtual int32_t getNumberOfRuleSetNames() const;
729 
737  virtual UnicodeString getRuleSetName(int32_t index) const;
738 
744  virtual int32_t getNumberOfRuleSetDisplayNameLocales(void) const;
745 
754  virtual Locale getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const;
755 
769  virtual UnicodeString getRuleSetDisplayName(int32_t index,
770  const Locale& locale = Locale::getDefault());
771 
780  virtual UnicodeString getRuleSetDisplayName(const UnicodeString& ruleSetName,
781  const Locale& locale = Locale::getDefault());
782 
783 
784  using NumberFormat::format;
785 
794  virtual UnicodeString& format(int32_t number,
795  UnicodeString& toAppendTo,
796  FieldPosition& pos) const;
797 
806  virtual UnicodeString& format(int64_t number,
807  UnicodeString& toAppendTo,
808  FieldPosition& pos) const;
817  virtual UnicodeString& format(double number,
818  UnicodeString& toAppendTo,
819  FieldPosition& pos) const;
820 
832  virtual UnicodeString& format(int32_t number,
833  const UnicodeString& ruleSetName,
834  UnicodeString& toAppendTo,
835  FieldPosition& pos,
836  UErrorCode& status) const;
848  virtual UnicodeString& format(int64_t number,
849  const UnicodeString& ruleSetName,
850  UnicodeString& toAppendTo,
851  FieldPosition& pos,
852  UErrorCode& status) const;
864  virtual UnicodeString& format(double number,
865  const UnicodeString& ruleSetName,
866  UnicodeString& toAppendTo,
867  FieldPosition& pos,
868  UErrorCode& status) const;
869 
870 protected:
888  virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
889  UnicodeString& appendTo,
890  FieldPosition& pos,
891  UErrorCode& status) const;
892 public:
893 
894  using NumberFormat::parse;
895 
910  virtual void parse(const UnicodeString& text,
911  Formattable& result,
912  ParsePosition& parsePosition) const;
913 
914 #if !UCONFIG_NO_COLLATION
915 
949  virtual void setLenient(UBool enabled);
950 
958  virtual inline UBool isLenient(void) const;
959 
960 #endif
961 
970  virtual void setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status);
971 
978  virtual UnicodeString getDefaultRuleSetName() const;
979 
990  virtual void setContext(UDisplayContext value, UErrorCode& status);
991 
997  virtual ERoundingMode getRoundingMode(void) const;
998 
1004  virtual void setRoundingMode(ERoundingMode roundingMode);
1005 
1006 public:
1012  static UClassID U_EXPORT2 getStaticClassID(void);
1013 
1019  virtual UClassID getDynamicClassID(void) const;
1020 
1029  virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
1030 
1040  virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
1041 
1042 private:
1043  RuleBasedNumberFormat(); // default constructor not implemented
1044 
1045  // this will ref the localizations if they are not NULL
1046  // caller must deref to get adoption
1047  RuleBasedNumberFormat(const UnicodeString& description, LocalizationInfo* localizations,
1048  const Locale& locale, UParseError& perror, UErrorCode& status);
1049 
1050  void init(const UnicodeString& rules, LocalizationInfo* localizations, UParseError& perror, UErrorCode& status);
1051  void initCapitalizationContextInfo(const Locale& thelocale);
1052  void dispose();
1053  void stripWhitespace(UnicodeString& src);
1054  void initDefaultRuleSet();
1055  NFRuleSet* findRuleSet(const UnicodeString& name, UErrorCode& status) const;
1056 
1057  /* friend access */
1058  friend class NFSubstitution;
1059  friend class NFRule;
1060  friend class NFRuleSet;
1061  friend class FractionalPartSubstitution;
1062 
1063  inline NFRuleSet * getDefaultRuleSet() const;
1064  const RuleBasedCollator * getCollator() const;
1065  DecimalFormatSymbols * initializeDecimalFormatSymbols(UErrorCode &status);
1066  const DecimalFormatSymbols * getDecimalFormatSymbols() const;
1067  NFRule * initializeDefaultInfinityRule(UErrorCode &status);
1068  const NFRule * getDefaultInfinityRule() const;
1069  NFRule * initializeDefaultNaNRule(UErrorCode &status);
1070  const NFRule * getDefaultNaNRule() const;
1071  PluralFormat *createPluralFormat(UPluralType pluralType, const UnicodeString &pattern, UErrorCode& status) const;
1072  UnicodeString& adjustForCapitalizationContext(int32_t startPos, UnicodeString& currentResult, UErrorCode& status) const;
1073  UnicodeString& format(int64_t number, NFRuleSet *ruleSet, UnicodeString& toAppendTo, UErrorCode& status) const;
1074  void format(double number, NFRuleSet& rs, UnicodeString& toAppendTo, UErrorCode& status) const;
1075 
1076 private:
1077  NFRuleSet **fRuleSets;
1078  UnicodeString* ruleSetDescriptions;
1079  int32_t numRuleSets;
1080  NFRuleSet *defaultRuleSet;
1081  Locale locale;
1082  RuleBasedCollator* collator;
1083  DecimalFormatSymbols* decimalFormatSymbols;
1084  NFRule *defaultInfinityRule;
1085  NFRule *defaultNaNRule;
1086  ERoundingMode fRoundingMode;
1087  UBool lenient;
1088  UnicodeString* lenientParseRules;
1089  LocalizationInfo* localizations;
1090  UnicodeString originalDescription;
1091  UBool capitalizationInfoSet;
1092  UBool capitalizationForUIListMenu;
1093  UBool capitalizationForStandAlone;
1094  BreakIterator* capitalizationBrkIter;
1095 };
1096 
1097 // ---------------
1098 
1099 #if !UCONFIG_NO_COLLATION
1100 
1101 inline UBool
1103  return lenient;
1104 }
1105 
1106 #endif
1107 
1108 inline NFRuleSet*
1109 RuleBasedNumberFormat::getDefaultRuleSet() const {
1110  return defaultRuleSet;
1111 }
1112 
1113 U_NAMESPACE_END
1114 
1115 /* U_HAVE_RBNF */
1116 #endif
1117 
1118 #endif /* U_SHOW_CPLUSPLUS_API */
1119 
1120 /* RBNF_H */
1121 #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 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.
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 UBool isLenient(void) const
Returns true if lenient-parse mode is turned on.
Definition: rbnf.h:1102
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:301
URBNFRuleSetTag
Tags for the predefined rulesets.
Definition: rbnf.h:56
One more than the highest normal URBNFRuleSetTag value.
Definition: rbnf.h:66
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.
The RuleBasedNumberFormat class formats numbers according to a set of rules.
Definition: rbnf.h:562
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
virtual NumberFormat * clone() const =0
Clones this object polymorphically.
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: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:52
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:294
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.
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:1261
int8_t UBool
The ICU boolean type.
Definition: umachine.h:261
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