ICU 4.8.1.1  4.8.1.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-2010, 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 
724 
725  using NumberFormat::format;
726 
735  virtual UnicodeString& format(int32_t number,
736  UnicodeString& toAppendTo,
737  FieldPosition& pos) const;
738 
747  virtual UnicodeString& format(int64_t number,
748  UnicodeString& toAppendTo,
749  FieldPosition& pos) const;
758  virtual UnicodeString& format(double number,
759  UnicodeString& toAppendTo,
760  FieldPosition& pos) const;
761 
773  virtual UnicodeString& format(int32_t number,
774  const UnicodeString& ruleSetName,
775  UnicodeString& toAppendTo,
776  FieldPosition& pos,
777  UErrorCode& status) const;
789  virtual UnicodeString& format(int64_t number,
790  const UnicodeString& ruleSetName,
791  UnicodeString& toAppendTo,
792  FieldPosition& pos,
793  UErrorCode& status) const;
805  virtual UnicodeString& format(double number,
806  const UnicodeString& ruleSetName,
807  UnicodeString& toAppendTo,
808  FieldPosition& pos,
809  UErrorCode& status) const;
810 
820  virtual UnicodeString& format(const Formattable& obj,
821  UnicodeString& toAppendTo,
822  FieldPosition& pos,
823  UErrorCode& status) const;
832  UnicodeString& format(const Formattable& obj,
833  UnicodeString& result,
834  UErrorCode& status) const;
835 
843  UnicodeString& format(double number,
844  UnicodeString& output) const;
845 
853  UnicodeString& format(int32_t number,
854  UnicodeString& output) const;
855 
870  virtual void parse(const UnicodeString& text,
871  Formattable& result,
872  ParsePosition& parsePosition) const;
873 
874 
882  virtual inline void parse(const UnicodeString& text,
883  Formattable& result,
884  UErrorCode& status) const;
885 
886 #if !UCONFIG_NO_COLLATION
887 
921  virtual void setLenient(UBool enabled);
922 
930  virtual inline UBool isLenient(void) const;
931 
932 #endif
933 
942  virtual void setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status);
943 
950  virtual UnicodeString getDefaultRuleSetName() const;
951 
952 public:
958  static UClassID U_EXPORT2 getStaticClassID(void);
959 
965  virtual UClassID getDynamicClassID(void) const;
966 
967 private:
968  RuleBasedNumberFormat(); // default constructor not implemented
969 
970  // this will ref the localizations if they are not NULL
971  // caller must deref to get adoption
972  RuleBasedNumberFormat(const UnicodeString& description, LocalizationInfo* localizations,
973  const Locale& locale, UParseError& perror, UErrorCode& status);
974 
975  void init(const UnicodeString& rules, LocalizationInfo* localizations, UParseError& perror, UErrorCode& status);
976  void dispose();
977  void stripWhitespace(UnicodeString& src);
978  void initDefaultRuleSet();
979  void format(double number, NFRuleSet& ruleSet);
980  NFRuleSet* findRuleSet(const UnicodeString& name, UErrorCode& status) const;
981 
982  /* friend access */
983  friend class NFSubstitution;
984  friend class NFRule;
985  friend class FractionalPartSubstitution;
986 
987  inline NFRuleSet * getDefaultRuleSet() const;
988  Collator * getCollator() const;
989  DecimalFormatSymbols * getDecimalFormatSymbols() const;
990 
991 private:
992  NFRuleSet **ruleSets;
993  NFRuleSet *defaultRuleSet;
994  Locale locale;
995  Collator* collator;
996  DecimalFormatSymbols* decimalFormatSymbols;
997  UBool lenient;
998  UnicodeString* lenientParseRules;
999  LocalizationInfo* localizations;
1000 
1001  // Temporary workaround - when noParse is true, do noting in parse.
1002  // TODO: We need a real fix - see #6895/#6896
1003  UBool noParse;
1004 };
1005 
1006 // ---------------
1007 
1008 inline UnicodeString&
1010  UnicodeString& result,
1011  UErrorCode& status) const
1012 {
1013  // Don't use Format:: - use immediate base class only,
1014  // in case immediate base modifies behavior later.
1015  // dlf - the above comment is bogus, if there were a reason to modify
1016  // it, it would be virtual, and there's no reason because it is
1017  // a one-line macro in NumberFormat anyway, just like this one.
1018  return NumberFormat::format(obj, result, status);
1019 }
1020 
1021 inline UnicodeString&
1022 RuleBasedNumberFormat::format(double number, UnicodeString& output) const {
1023  FieldPosition pos(0);
1024  return format(number, output, pos);
1025 }
1026 
1027 inline UnicodeString&
1028 RuleBasedNumberFormat::format(int32_t number, UnicodeString& output) const {
1029  FieldPosition pos(0);
1030  return format(number, output, pos);
1031 }
1032 
1033 inline void
1035 {
1036  NumberFormat::parse(text, result, status);
1037 }
1038 
1039 #if !UCONFIG_NO_COLLATION
1040 
1041 inline UBool
1043  return lenient;
1044 }
1045 
1046 #endif
1047 
1048 inline NFRuleSet*
1049 RuleBasedNumberFormat::getDefaultRuleSet() const {
1050  return defaultRuleSet;
1051 }
1052 
1054 
1055 /* U_HAVE_RBNF */
1056 #endif
1057 
1058 /* RBNF_H */
1059 #endif
virtual UBool isLenient(void) const
Returns whether lenient parsing is enabled (it is off by default).
Definition: numfmt.h:1045
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.
virtual void setLenient(UBool enable)
Sets whether lenient parsing should be enabled (it is off by default).
This class represents the set of symbols needed by DecimalFormat to format numbers.
Definition: dcfmtsym.h:84
#define U_I18N_API
Set to export library symbols from inside the i18n library, and to import them from outside...
Definition: utypes.h:521
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:131
Abstract base class for all number formats.
Definition: numfmt.h:165
C++ API: Collation Service.
virtual UBool isLenient(void) const
Returns true if lenient-parse mode is turned on.
Definition: rbnf.h:1042
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:188
#define U_EXPORT2
Definition: platform.h:314
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.
Definition: uversion.h:132
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:52
void * UClassID
UClassID is used to identify classes without using RTTI, since RTTI is not yet supported by all C++ c...
Definition: utypes.h:385
UErrorCode
Error code to replace exception handling, so that the code is compatible with all C++ compilers...
Definition: utypes.h:639
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.
A UParseError struct is used to returned detailed information about parsing errors.
Definition: parseerr.h:56
Base class for all formats.
Definition: format.h:94
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
int8_t UBool
The ICU boolean type.
Definition: umachine.h:228
C++ API: Formattable is a thin wrapper for primitive numeric types.