ICU 53.1  53.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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 
39 
40 class NFRuleSet;
41 class LocalizationInfo;
42 class RuleBasedCollator;
43 
50  URBNF_SPELLOUT,
51  URBNF_ORDINAL,
52  URBNF_DURATION,
53  URBNF_NUMBERING_SYSTEM,
54  URBNF_COUNT
55 };
56 
501 public:
502 
503  //-----------------------------------------------------------------------
504  // constructors
505  //-----------------------------------------------------------------------
506 
517  RuleBasedNumberFormat(const UnicodeString& rules, UParseError& perror, UErrorCode& status);
518 
542  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
543  UParseError& perror, UErrorCode& status);
544 
560  RuleBasedNumberFormat(const UnicodeString& rules, const Locale& locale,
561  UParseError& perror, UErrorCode& status);
562 
589  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
590  const Locale& locale, UParseError& perror, UErrorCode& status);
591 
607  RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& locale, UErrorCode& status);
608 
609  //-----------------------------------------------------------------------
610  // boilerplate
611  //-----------------------------------------------------------------------
612 
619 
626 
631  virtual ~RuleBasedNumberFormat();
632 
639  virtual Format* clone(void) const;
640 
648  virtual UBool operator==(const Format& other) const;
649 
650 //-----------------------------------------------------------------------
651 // public API functions
652 //-----------------------------------------------------------------------
653 
659  virtual UnicodeString getRules() const;
660 
666  virtual int32_t getNumberOfRuleSetNames() const;
667 
675  virtual UnicodeString getRuleSetName(int32_t index) const;
676 
682  virtual int32_t getNumberOfRuleSetDisplayNameLocales(void) const;
683 
692  virtual Locale getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const;
693 
707  virtual UnicodeString getRuleSetDisplayName(int32_t index,
708  const Locale& locale = Locale::getDefault());
709 
718  virtual UnicodeString getRuleSetDisplayName(const UnicodeString& ruleSetName,
719  const Locale& locale = Locale::getDefault());
720 
721 
722  using NumberFormat::format;
723 
732  virtual UnicodeString& format(int32_t number,
733  UnicodeString& toAppendTo,
734  FieldPosition& pos) const;
735 
744  virtual UnicodeString& format(int64_t number,
745  UnicodeString& toAppendTo,
746  FieldPosition& pos) const;
755  virtual UnicodeString& format(double number,
756  UnicodeString& toAppendTo,
757  FieldPosition& pos) const;
758 
770  virtual UnicodeString& format(int32_t number,
771  const UnicodeString& ruleSetName,
772  UnicodeString& toAppendTo,
773  FieldPosition& pos,
774  UErrorCode& status) const;
786  virtual UnicodeString& format(int64_t number,
787  const UnicodeString& ruleSetName,
788  UnicodeString& toAppendTo,
789  FieldPosition& pos,
790  UErrorCode& status) const;
802  virtual UnicodeString& format(double number,
803  const UnicodeString& ruleSetName,
804  UnicodeString& toAppendTo,
805  FieldPosition& pos,
806  UErrorCode& status) const;
807 
808  using NumberFormat::parse;
809 
824  virtual void parse(const UnicodeString& text,
825  Formattable& result,
826  ParsePosition& parsePosition) const;
827 
828 #if !UCONFIG_NO_COLLATION
829 
863  virtual void setLenient(UBool enabled);
864 
872  virtual inline UBool isLenient(void) const;
873 
874 #endif
875 
884  virtual void setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status);
885 
892  virtual UnicodeString getDefaultRuleSetName() const;
893 
894  /* Cannot use #ifndef U_HIDE_DRAFT_API for the following draft method since it is virtual */
905  virtual void setContext(UDisplayContext value, UErrorCode& status);
906 
907 public:
913  static UClassID U_EXPORT2 getStaticClassID(void);
914 
920  virtual UClassID getDynamicClassID(void) const;
921 
930  virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
931 
941  virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
942 
943 private:
944  RuleBasedNumberFormat(); // default constructor not implemented
945 
946  // this will ref the localizations if they are not NULL
947  // caller must deref to get adoption
948  RuleBasedNumberFormat(const UnicodeString& description, LocalizationInfo* localizations,
949  const Locale& locale, UParseError& perror, UErrorCode& status);
950 
951  void init(const UnicodeString& rules, LocalizationInfo* localizations, UParseError& perror, UErrorCode& status);
952  void initCapitalizationContextInfo(const Locale& thelocale);
953  void dispose();
954  void stripWhitespace(UnicodeString& src);
955  void initDefaultRuleSet();
956  void format(double number, NFRuleSet& ruleSet);
957  NFRuleSet* findRuleSet(const UnicodeString& name, UErrorCode& status) const;
958 
959  /* friend access */
960  friend class NFSubstitution;
961  friend class NFRule;
962  friend class FractionalPartSubstitution;
963 
964  inline NFRuleSet * getDefaultRuleSet() const;
965  const RuleBasedCollator * getCollator() const;
966  DecimalFormatSymbols * getDecimalFormatSymbols() const;
967  UnicodeString& adjustForCapitalizationContext(int32_t startPos, UnicodeString& currentResult) const;
968 
969 private:
970  NFRuleSet **ruleSets;
971  UnicodeString* ruleSetDescriptions;
972  int32_t numRuleSets;
973  NFRuleSet *defaultRuleSet;
974  Locale locale;
975  RuleBasedCollator* collator;
976  DecimalFormatSymbols* decimalFormatSymbols;
977  UBool lenient;
978  UnicodeString* lenientParseRules;
979  LocalizationInfo* localizations;
980  UnicodeString originalDescription;
981  UBool capitalizationInfoSet;
982  UBool capitalizationForUIListMenu;
983  UBool capitalizationForStandAlone;
984  BreakIterator* capitalizationBrkIter;
985 };
986 
987 // ---------------
988 
989 #if !UCONFIG_NO_COLLATION
990 
991 inline UBool
992 RuleBasedNumberFormat::isLenient(void) const {
993  return lenient;
994 }
995 
996 #endif
997 
998 inline NFRuleSet*
999 RuleBasedNumberFormat::getDefaultRuleSet() const {
1000  return defaultRuleSet;
1001 }
1002 
1004 
1005 /* U_HAVE_RBNF */
1006 #endif
1007 
1008 /* RBNF_H */
1009 #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:49
#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:110
The BreakIterator class implements methods for finding the location of boundaries in text...
Definition: brkiter.h:100
The RuleBasedNumberFormat class formats numbers according to a set of rules.
Definition: rbnf.h:500
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
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:200
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