ICU 54.1  54.1
rbnf.h
Go to the documentation of this file.
1 /*
2 *******************************************************************************
3 * Copyright (C) 1997-2014, International Business Machines Corporation and others.
4 * All Rights Reserved.
5 *******************************************************************************
6 */
7 
8 #ifndef RBNF_H
9 #define RBNF_H
10 
11 #include "unicode/utypes.h"
12 
25 #if UCONFIG_NO_FORMATTING
26 #define U_HAVE_RBNF 0
27 #else
28 #define U_HAVE_RBNF 1
29 
30 #include "unicode/dcfmtsym.h"
31 #include "unicode/fmtable.h"
32 #include "unicode/locid.h"
33 #include "unicode/numfmt.h"
34 #include "unicode/unistr.h"
35 #include "unicode/strenum.h"
36 #include "unicode/brkiter.h"
37 #include "unicode/upluralrules.h"
38 
40 
41 class NFRuleSet;
42 class LocalizationInfo;
43 class PluralFormat;
44 class RuleBasedCollator;
45 
52  URBNF_SPELLOUT,
53  URBNF_ORDINAL,
54  URBNF_DURATION,
55  URBNF_NUMBERING_SYSTEM,
56  URBNF_COUNT
57 };
58 
523 public:
524 
525  //-----------------------------------------------------------------------
526  // constructors
527  //-----------------------------------------------------------------------
528 
539  RuleBasedNumberFormat(const UnicodeString& rules, UParseError& perror, UErrorCode& status);
540 
564  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
565  UParseError& perror, UErrorCode& status);
566 
582  RuleBasedNumberFormat(const UnicodeString& rules, const Locale& locale,
583  UParseError& perror, UErrorCode& status);
584 
611  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
612  const Locale& locale, UParseError& perror, UErrorCode& status);
613 
629  RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& locale, UErrorCode& status);
630 
631  //-----------------------------------------------------------------------
632  // boilerplate
633  //-----------------------------------------------------------------------
634 
641 
648 
653  virtual ~RuleBasedNumberFormat();
654 
661  virtual Format* clone(void) const;
662 
670  virtual UBool operator==(const Format& other) const;
671 
672 //-----------------------------------------------------------------------
673 // public API functions
674 //-----------------------------------------------------------------------
675 
681  virtual UnicodeString getRules() const;
682 
688  virtual int32_t getNumberOfRuleSetNames() const;
689 
697  virtual UnicodeString getRuleSetName(int32_t index) const;
698 
704  virtual int32_t getNumberOfRuleSetDisplayNameLocales(void) const;
705 
714  virtual Locale getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const;
715 
729  virtual UnicodeString getRuleSetDisplayName(int32_t index,
730  const Locale& locale = Locale::getDefault());
731 
740  virtual UnicodeString getRuleSetDisplayName(const UnicodeString& ruleSetName,
741  const Locale& locale = Locale::getDefault());
742 
743 
744  using NumberFormat::format;
745 
754  virtual UnicodeString& format(int32_t number,
755  UnicodeString& toAppendTo,
756  FieldPosition& pos) const;
757 
766  virtual UnicodeString& format(int64_t number,
767  UnicodeString& toAppendTo,
768  FieldPosition& pos) const;
777  virtual UnicodeString& format(double number,
778  UnicodeString& toAppendTo,
779  FieldPosition& pos) const;
780 
792  virtual UnicodeString& format(int32_t number,
793  const UnicodeString& ruleSetName,
794  UnicodeString& toAppendTo,
795  FieldPosition& pos,
796  UErrorCode& status) const;
808  virtual UnicodeString& format(int64_t number,
809  const UnicodeString& ruleSetName,
810  UnicodeString& toAppendTo,
811  FieldPosition& pos,
812  UErrorCode& status) const;
824  virtual UnicodeString& format(double number,
825  const UnicodeString& ruleSetName,
826  UnicodeString& toAppendTo,
827  FieldPosition& pos,
828  UErrorCode& status) const;
829 
830  using NumberFormat::parse;
831 
846  virtual void parse(const UnicodeString& text,
847  Formattable& result,
848  ParsePosition& parsePosition) const;
849 
850 #if !UCONFIG_NO_COLLATION
851 
885  virtual void setLenient(UBool enabled);
886 
894  virtual inline UBool isLenient(void) const;
895 
896 #endif
897 
906  virtual void setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status);
907 
914  virtual UnicodeString getDefaultRuleSetName() const;
915 
916  /* Cannot use #ifndef U_HIDE_DRAFT_API for the following draft method since it is virtual */
927  virtual void setContext(UDisplayContext value, UErrorCode& status);
928 
929 public:
935  static UClassID U_EXPORT2 getStaticClassID(void);
936 
942  virtual UClassID getDynamicClassID(void) const;
943 
952  virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
953 
963  virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
964 
965 private:
966  RuleBasedNumberFormat(); // default constructor not implemented
967 
968  // this will ref the localizations if they are not NULL
969  // caller must deref to get adoption
970  RuleBasedNumberFormat(const UnicodeString& description, LocalizationInfo* localizations,
971  const Locale& locale, UParseError& perror, UErrorCode& status);
972 
973  void init(const UnicodeString& rules, LocalizationInfo* localizations, UParseError& perror, UErrorCode& status);
974  void initCapitalizationContextInfo(const Locale& thelocale);
975  void dispose();
976  void stripWhitespace(UnicodeString& src);
977  void initDefaultRuleSet();
978  void format(double number, NFRuleSet& ruleSet);
979  NFRuleSet* findRuleSet(const UnicodeString& name, UErrorCode& status) const;
980 
981  /* friend access */
982  friend class NFSubstitution;
983  friend class NFRule;
984  friend class FractionalPartSubstitution;
985 
986  inline NFRuleSet * getDefaultRuleSet() const;
987  const RuleBasedCollator * getCollator() const;
988  DecimalFormatSymbols * getDecimalFormatSymbols() const;
989  PluralFormat *createPluralFormat(UPluralType pluralType, const UnicodeString &pattern, UErrorCode& status) const;
990  UnicodeString& adjustForCapitalizationContext(int32_t startPos, UnicodeString& currentResult) const;
991 
992 private:
993  NFRuleSet **ruleSets;
994  UnicodeString* ruleSetDescriptions;
995  int32_t numRuleSets;
996  NFRuleSet *defaultRuleSet;
997  Locale locale;
998  RuleBasedCollator* collator;
999  DecimalFormatSymbols* decimalFormatSymbols;
1000  UBool lenient;
1001  UnicodeString* lenientParseRules;
1002  LocalizationInfo* localizations;
1003  UnicodeString originalDescription;
1004  UBool capitalizationInfoSet;
1005  UBool capitalizationForUIListMenu;
1006  UBool capitalizationForStandAlone;
1007  BreakIterator* capitalizationBrkIter;
1008 };
1009 
1010 // ---------------
1011 
1012 #if !UCONFIG_NO_COLLATION
1013 
1014 inline UBool
1015 RuleBasedNumberFormat::isLenient(void) const {
1016  return lenient;
1017 }
1018 
1019 #endif
1020 
1021 inline NFRuleSet*
1022 RuleBasedNumberFormat::getDefaultRuleSet() const {
1023  return defaultRuleSet;
1024 }
1025 
1027 
1028 /* U_HAVE_RBNF */
1029 #endif
1030 
1031 /* RBNF_H */
1032 #endif
C++ API: Break Iterator.
Base class for all formats.
Definition: format.h:94
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.
Abstract base class for all number formats.
Definition: numfmt.h:172
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:91
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:1177
#define U_I18N_API
Set to export library symbols from inside the i18n library, and to import them from outside...
Definition: utypes.h:358
URBNFRuleSetTag
Tags for the predefined rulesets.
Definition: rbnf.h:51
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:129
The RuleBasedCollator class provides the implementation of Collator, using data-driven tables...
Definition: tblcoll.h:111
The BreakIterator class implements methods for finding the location of boundaries in text...
Definition: brkiter.h:100
C API: Plural rules, select plural keywords for numeric values.
The RuleBasedNumberFormat class formats numbers according to a set of rules.
Definition: rbnf.h:522
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:130
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:476
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:106
UPluralType
Type of plurals and PluralRules.
Definition: upluralrules.h:44
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:47
C++ API: Locale ID object.
A UParseError struct is used to returned detailed information about parsing errors.
Definition: parseerr.h:56
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:245
Formattable objects can be passed to the Format class or its subclasses for formatting.
Definition: fmtable.h:66
virtual UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const
Format an object to produce a string.
C++ API: Abstract base class for all number formats.
NumberFormat & operator=(const NumberFormat &)
Assignment operator.
int8_t UBool
The ICU boolean type.
Definition: umachine.h:234
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:185