ICU 4.2.1
 All Data Structures 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-2009, 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/coll.h"
31 #include "unicode/dcfmtsym.h"
32 #include "unicode/fmtable.h"
33 #include "unicode/locid.h"
34 #include "unicode/numfmt.h"
35 #include "unicode/unistr.h"
36 #include "unicode/strenum.h"
37 
39 
40 class NFRuleSet;
41 class LocalizationInfo;
42 
49  URBNF_SPELLOUT,
50  URBNF_ORDINAL,
51  URBNF_DURATION,
52  URBNF_NUMBERING_SYSTEM,
53  URBNF_COUNT
54 };
55 
56 #if UCONFIG_NO_COLLATION
57 class Collator;
58 #endif
59 
504 public:
505 
506  //-----------------------------------------------------------------------
507  // constructors
508  //-----------------------------------------------------------------------
509 
520  RuleBasedNumberFormat(const UnicodeString& rules, UParseError& perror, UErrorCode& status);
521 
545  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
546  UParseError& perror, UErrorCode& status);
547 
563  RuleBasedNumberFormat(const UnicodeString& rules, const Locale& locale,
564  UParseError& perror, UErrorCode& status);
565 
592  RuleBasedNumberFormat(const UnicodeString& rules, const UnicodeString& localizations,
593  const Locale& locale, UParseError& perror, UErrorCode& status);
594 
610  RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& locale, UErrorCode& status);
611 
612  //-----------------------------------------------------------------------
613  // boilerplate
614  //-----------------------------------------------------------------------
615 
622 
629 
634  virtual ~RuleBasedNumberFormat();
635 
642  virtual Format* clone(void) const;
643 
651  virtual UBool operator==(const Format& other) const;
652 
653 //-----------------------------------------------------------------------
654 // public API functions
655 //-----------------------------------------------------------------------
656 
662  virtual UnicodeString getRules() const;
663 
669  virtual int32_t getNumberOfRuleSetNames() const;
670 
678  virtual UnicodeString getRuleSetName(int32_t index) const;
679 
685  virtual int32_t getNumberOfRuleSetDisplayNameLocales(void) const;
686 
695  virtual Locale getRuleSetDisplayNameLocale(int32_t index, UErrorCode& status) const;
696 
710  virtual UnicodeString getRuleSetDisplayName(int32_t index,
711  const Locale& locale = Locale::getDefault());
712 
721  virtual UnicodeString getRuleSetDisplayName(const UnicodeString& ruleSetName,
722  const Locale& locale = Locale::getDefault());
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 
817  virtual UnicodeString& format(const Formattable& obj,
818  UnicodeString& toAppendTo,
819  FieldPosition& pos,
820  UErrorCode& status) const;
829  UnicodeString& format(const Formattable& obj,
830  UnicodeString& result,
831  UErrorCode& status) const;
832 
840  UnicodeString& format(double number,
841  UnicodeString& output) const;
842 
850  UnicodeString& format(int32_t number,
851  UnicodeString& output) const;
852 
867  virtual void parse(const UnicodeString& text,
868  Formattable& result,
869  ParsePosition& parsePosition) const;
870 
871 
879  virtual inline void parse(const UnicodeString& text,
880  Formattable& result,
881  UErrorCode& status) const;
882 
883 #if !UCONFIG_NO_COLLATION
884 
918  virtual void setLenient(UBool enabled);
919 
927  virtual inline UBool isLenient(void) const;
928 
929 #endif
930 
939  virtual void setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status);
940 
947  virtual UnicodeString getDefaultRuleSetName() const;
948 
949 public:
955  static UClassID U_EXPORT2 getStaticClassID(void);
956 
962  virtual UClassID getDynamicClassID(void) const;
963 
964 private:
965  RuleBasedNumberFormat(); // default constructor not implemented
966 
967  // this will ref the localizations if they are not NULL
968  // caller must deref to get adoption
969  RuleBasedNumberFormat(const UnicodeString& description, LocalizationInfo* localizations,
970  const Locale& locale, UParseError& perror, UErrorCode& status);
971 
972  void init(const UnicodeString& rules, LocalizationInfo* localizations, UParseError& perror, UErrorCode& status);
973  void dispose();
974  void stripWhitespace(UnicodeString& src);
975  void initDefaultRuleSet();
976  void format(double number, NFRuleSet& ruleSet);
977  NFRuleSet* findRuleSet(const UnicodeString& name, UErrorCode& status) const;
978 
979  /* friend access */
980  friend class NFSubstitution;
981  friend class NFRule;
982  friend class FractionalPartSubstitution;
983 
984  inline NFRuleSet * getDefaultRuleSet() const;
985  Collator * getCollator() const;
986  DecimalFormatSymbols * getDecimalFormatSymbols() const;
987 
988 private:
989  NFRuleSet **ruleSets;
990  NFRuleSet *defaultRuleSet;
991  Locale locale;
992  Collator* collator;
993  DecimalFormatSymbols* decimalFormatSymbols;
994  UBool lenient;
995  UnicodeString* lenientParseRules;
996  LocalizationInfo* localizations;
997 
998  // Temporary workaround - when noParse is true, do noting in parse.
999  // TODO: We need a real fix - see #6895/#6896
1000  UBool noParse;
1001 };
1002 
1003 // ---------------
1004 
1005 inline UnicodeString&
1007  UnicodeString& result,
1008  UErrorCode& status) const
1009 {
1010  // Don't use Format:: - use immediate base class only,
1011  // in case immediate base modifies behavior later.
1012  // dlf - the above comment is bogus, if there were a reason to modify
1013  // it, it would be virtual, and there's no reason because it is
1014  // a one-line macro in NumberFormat anyway, just like this one.
1015  return NumberFormat::format(obj, result, status);
1016 }
1017 
1018 inline UnicodeString&
1019 RuleBasedNumberFormat::format(double number, UnicodeString& output) const {
1020  FieldPosition pos(0);
1021  return format(number, output, pos);
1022 }
1023 
1024 inline UnicodeString&
1026  FieldPosition pos(0);
1027  return format(number, output, pos);
1028 }
1029 
1030 inline void
1032 {
1033  NumberFormat::parse(text, result, status);
1034 }
1035 
1036 #if !UCONFIG_NO_COLLATION
1037 
1038 inline UBool
1040  return lenient;
1041 }
1042 
1043 #endif
1044 
1045 inline NFRuleSet*
1046 RuleBasedNumberFormat::getDefaultRuleSet() const {
1047  return defaultRuleSet;
1048 }
1049 
1051 
1052 /* U_HAVE_RBNF */
1053 #endif
1054 
1055 /* RBNF_H */
1056 #endif
static UClassID getStaticClassID(void)
Return the class ID for this class.
virtual void parse(const UnicodeString &text, Formattable &result, ParsePosition &parsePosition) const =0
Return a long if possible (e.g.
C++ API: Unicode String.
virtual void parse(const UnicodeString &text, Formattable &result, ParsePosition &parsePosition) const
Parses the specfied string, beginning at the specified position, according to this formatter's rules...
virtual UBool operator==(const Format &other) const
Return true if the given Format objects are semantically equal.
This class represents the set of symbols needed by DecimalFormat to format numbers.
Definition: dcfmtsym.h:82
#define U_I18N_API
Set to export library symbols from inside the i18n library, and to import them from outside...
Definition: utypes.h:475
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:183
Abstract base class for all number formats.
Definition: numfmt.h:162
C++ API: Collation Service.
virtual UBool isLenient(void) const
Returns true if lenient-parse mode is turned on.
Definition: rbnf.h:1039
NumberFormat & operator=(const NumberFormat &)
Assignment operator.
ParsePosition is a simple class used by Format and its subclasses to keep track of the current positi...
Definition: parsepos.h:47
virtual UnicodeString & format(int32_t number, UnicodeString &toAppendTo, FieldPosition &pos) const
Formats the specified 32-bit number using the default ruleset.
URBNFRuleSetTag
Tags for the predefined rulesets.
Definition: rbnf.h:48
The Collator class performs locale-sensitive string comparison.
Definition: coll.h:177
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:187
#define U_EXPORT2
Definition: platform.h:338
The RuleBasedNumberFormat class formats numbers according to a set of rules.
Definition: rbnf.h:503
virtual UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const
Format an object to produce a string.
virtual Format * clone() const =0
Clone this object polymorphically.
FieldPosition is a simple class used by Format and its subclasses to identify fields in formatted out...
Definition: fieldpos.h:106
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API If the compiler doesn't support namespaces...
Definition: uversion.h:184
static const Locale & getDefault(void)
Common methods of getting the current default Locale.
Formattable objects can be passed to the Format class or its subclasses for formatting.
Definition: fmtable.h:47
void * UClassID
UClassID is used to identify classes without using RTTI, since RTTI is not yet supported by all C++ c...
Definition: utypes.h:339
UErrorCode
Error code to replace exception handling, so that the code is compatible with all C++ compilers...
Definition: utypes.h:593
virtual UClassID getDynamicClassID(void) const =0
Returns a unique class ID POLYMORPHICALLY.
C++ API: Symbols for formatting numbers.
C++ API: String Enumeration.
C++ API: Locale ID object.
signed long long int64_t
Define 64 bit limits.
Definition: pwin32.h:152
A UParseError struct is used to returned detailed information about parsing errors.
Definition: parseerr.h:56
Base class for all formats.
Definition: format.h:93
Basic definitions for ICU, for both C and C++ APIs.
C++ API: Abstract base class for all number formats.
A Locale object represents a specific geographical, political, or cultural region.
Definition: locid.h:181
signed int int32_t
Define 64 bit limits.
Definition: pwin32.h:143
int8_t UBool
The ICU boolean type.
Definition: umachine.h:208
C++ API: Formattable is a thin wrapper for primitive numeric types.