ICU 50.1.2  50.1.2
numfmt.h
Go to the documentation of this file.
1 /*
2 ********************************************************************************
3 * Copyright (C) 1997-2012, International Business Machines Corporation and others.
4 * All Rights Reserved.
5 ********************************************************************************
6 *
7 * File NUMFMT.H
8 *
9 * Modification History:
10 *
11 * Date Name Description
12 * 02/19/97 aliu Converted from java.
13 * 03/18/97 clhuang Updated per C++ implementation.
14 * 04/17/97 aliu Changed DigitCount to int per code review.
15 * 07/20/98 stephen JDK 1.2 sync up. Added scientific support.
16 * Changed naming conventions to match C++ guidelines
17 * Derecated Java style constants (eg, INTEGER_FIELD)
18 ********************************************************************************
19 */
20 
21 #ifndef NUMFMT_H
22 #define NUMFMT_H
23 
24 
25 #include "unicode/utypes.h"
26 
32 #if !UCONFIG_NO_FORMATTING
33 
34 #include "unicode/unistr.h"
35 #include "unicode/format.h"
36 #include "unicode/unum.h" // UNumberFormatStyle
37 #include "unicode/locid.h"
38 #include "unicode/stringpiece.h"
39 #include "unicode/curramt.h"
40 
41 class NumberFormatTest;
42 
44 
45 #if !UCONFIG_NO_SERVICE
46 class NumberFormatFactory;
47 class StringEnumeration;
48 #endif
49 
167 public:
185  kIntegerField = UNUM_INTEGER_FIELD,
187  kFractionField = UNUM_FRACTION_FIELD,
189  kDecimalSeparatorField = UNUM_DECIMAL_SEPARATOR_FIELD,
191  kExponentSymbolField = UNUM_EXPONENT_SYMBOL_FIELD,
193  kExponentSignField = UNUM_EXPONENT_SIGN_FIELD,
195  kExponentField = UNUM_EXPONENT_FIELD,
197  kGroupingSeparatorField = UNUM_GROUPING_SEPARATOR_FIELD,
199  kCurrencyField = UNUM_CURRENCY_FIELD,
201  kPercentField = UNUM_PERCENT_FIELD,
203  kPermillField = UNUM_PERMILL_FIELD,
205  kSignField = UNUM_SIGN_FIELD,
206 
212  INTEGER_FIELD = UNUM_INTEGER_FIELD,
214  FRACTION_FIELD = UNUM_FRACTION_FIELD
215  };
216 
221  virtual ~NumberFormat();
222 
229  virtual UBool operator==(const Format& other) const;
230 
231 
232  using Format::format;
233 
249  virtual UnicodeString& format(const Formattable& obj,
250  UnicodeString& appendTo,
251  FieldPosition& pos,
252  UErrorCode& status) const;
253 
270  virtual UnicodeString& format(const Formattable& obj,
271  UnicodeString& appendTo,
272  FieldPositionIterator* posIter,
273  UErrorCode& status) const;
274 
303  virtual void parseObject(const UnicodeString& source,
304  Formattable& result,
305  ParsePosition& parse_pos) const;
306 
317  UnicodeString& format( double number,
318  UnicodeString& appendTo) const;
319 
330  UnicodeString& format( int32_t number,
331  UnicodeString& appendTo) const;
332 
343  UnicodeString& format( int64_t number,
344  UnicodeString& appendTo) const;
345 
358  virtual UnicodeString& format(double number,
359  UnicodeString& appendTo,
360  FieldPosition& pos) const = 0;
375  virtual UnicodeString& format(double number,
376  UnicodeString& appendTo,
377  FieldPosition& pos,
378  UErrorCode &status) const;
393  virtual UnicodeString& format(double number,
394  UnicodeString& appendTo,
395  FieldPositionIterator* posIter,
396  UErrorCode& status) const;
409  virtual UnicodeString& format(int32_t number,
410  UnicodeString& appendTo,
411  FieldPosition& pos) const = 0;
412 
426  virtual UnicodeString& format(int32_t number,
427  UnicodeString& appendTo,
428  FieldPosition& pos,
429  UErrorCode &status) const;
430 
445  virtual UnicodeString& format(int32_t number,
446  UnicodeString& appendTo,
447  FieldPositionIterator* posIter,
448  UErrorCode& status) const;
462  virtual UnicodeString& format(int64_t number,
463  UnicodeString& appendTo,
464  FieldPosition& pos) const;
465 
479  virtual UnicodeString& format(int64_t number,
480  UnicodeString& appendTo,
481  FieldPosition& pos,
482  UErrorCode& status) const;
497  virtual UnicodeString& format(int64_t number,
498  UnicodeString& appendTo,
499  FieldPositionIterator* posIter,
500  UErrorCode& status) const;
501 
518  virtual UnicodeString& format(const StringPiece &number,
519  UnicodeString& appendTo,
520  FieldPositionIterator* posIter,
521  UErrorCode& status) const;
522 public:
540  virtual UnicodeString& format(const DigitList &number,
541  UnicodeString& appendTo,
542  FieldPositionIterator* posIter,
543  UErrorCode& status) const;
544 
562  virtual UnicodeString& format(const DigitList &number,
563  UnicodeString& appendTo,
564  FieldPosition& pos,
565  UErrorCode& status) const;
566 
567 public:
568 
579  UnicodeString& format(const Formattable& obj,
580  UnicodeString& appendTo,
581  UErrorCode& status) const;
582 
602  virtual void parse(const UnicodeString& text,
603  Formattable& result,
604  ParsePosition& parsePosition) const = 0;
605 
619  virtual void parse(const UnicodeString& text,
620  Formattable& result,
621  UErrorCode& status) const;
622 
623 /* Cannot use #ifndef U_HIDE_DRAFT_API for the following draft method since it is virtual */
643  virtual CurrencyAmount* parseCurrency(const UnicodeString& text,
644  ParsePosition& pos) const;
645 
657  UBool isParseIntegerOnly(void) const;
658 
666  virtual void setParseIntegerOnly(UBool value);
667 
675  virtual void setLenient(UBool enable);
676 
685  virtual UBool isLenient(void) const;
686 
695  static NumberFormat* U_EXPORT2 createInstance(UErrorCode&);
696 
705  static NumberFormat* U_EXPORT2 createInstance(const Locale& inLocale,
706  UErrorCode&);
707 
716  static NumberFormat* U_EXPORT2 createInstance(const Locale& desiredLocale,
717  UNumberFormatStyle style,
718  UErrorCode& errorCode);
719 
724  static NumberFormat* U_EXPORT2 createCurrencyInstance(UErrorCode&);
725 
731  static NumberFormat* U_EXPORT2 createCurrencyInstance(const Locale& inLocale,
732  UErrorCode&);
733 
738  static NumberFormat* U_EXPORT2 createPercentInstance(UErrorCode&);
739 
745  static NumberFormat* U_EXPORT2 createPercentInstance(const Locale& inLocale,
746  UErrorCode&);
747 
752  static NumberFormat* U_EXPORT2 createScientificInstance(UErrorCode&);
753 
759  static NumberFormat* U_EXPORT2 createScientificInstance(const Locale& inLocale,
760  UErrorCode&);
761 
767  static const Locale* U_EXPORT2 getAvailableLocales(int32_t& count);
768 
769 #if !UCONFIG_NO_SERVICE
770 
777  static URegistryKey U_EXPORT2 registerFactory(NumberFormatFactory* toAdopt, UErrorCode& status);
778 
788  static UBool U_EXPORT2 unregister(URegistryKey key, UErrorCode& status);
789 
796  static StringEnumeration* U_EXPORT2 getAvailableLocales(void);
797 #endif /* UCONFIG_NO_SERVICE */
798 
808  UBool isGroupingUsed(void) const;
809 
816  virtual void setGroupingUsed(UBool newValue);
817 
826  int32_t getMaximumIntegerDigits(void) const;
827 
840  virtual void setMaximumIntegerDigits(int32_t newValue);
841 
850  int32_t getMinimumIntegerDigits(void) const;
851 
862  virtual void setMinimumIntegerDigits(int32_t newValue);
863 
872  int32_t getMaximumFractionDigits(void) const;
873 
884  virtual void setMaximumFractionDigits(int32_t newValue);
885 
894  int32_t getMinimumFractionDigits(void) const;
895 
906  virtual void setMinimumFractionDigits(int32_t newValue);
907 
920  virtual void setCurrency(const UChar* theCurrency, UErrorCode& ec);
921 
929  const UChar* getCurrency() const;
930 
931 public:
932 
941  static UClassID U_EXPORT2 getStaticClassID(void);
942 
954  virtual UClassID getDynamicClassID(void) const = 0;
955 
956 protected:
957 
962  NumberFormat();
963 
968  NumberFormat(const NumberFormat&);
969 
975 
984  virtual void getEffectiveCurrency(UChar* result, UErrorCode& ec) const;
985 
986 private:
987 
988  static UBool isStyleSupported(UNumberFormatStyle style);
989 
997  static NumberFormat* makeInstance(const Locale& desiredLocale,
998  UNumberFormatStyle style,
999  UErrorCode& errorCode);
1000 
1001  UBool fGroupingUsed;
1002  int32_t fMaxIntegerDigits;
1003  int32_t fMinIntegerDigits;
1004  int32_t fMaxFractionDigits;
1005  int32_t fMinFractionDigits;
1006  UBool fParseIntegerOnly;
1007  UBool fLenient; // TRUE => lenient parse is enabled
1008 
1009  // ISO currency code
1010  UChar fCurrency[4];
1011 
1012  friend class ICUNumberFormatFactory; // access to makeInstance
1013  friend class ICUNumberFormatService;
1014  friend class ::NumberFormatTest; // access to isStyleSupported()
1015 };
1016 
1017 #if !UCONFIG_NO_SERVICE
1018 
1027 public:
1028 
1033  virtual ~NumberFormatFactory();
1034 
1041  virtual UBool visible(void) const = 0;
1042 
1048  virtual const UnicodeString * getSupportedIDs(int32_t &count, UErrorCode& status) const = 0;
1049 
1057  virtual NumberFormat* createFormat(const Locale& loc, UNumberFormatStyle formatType) = 0;
1058 };
1059 
1065 protected:
1071 
1077 
1078 public:
1082  SimpleNumberFormatFactory(const Locale& locale, UBool visible = TRUE);
1083 
1087  virtual ~SimpleNumberFormatFactory();
1088 
1092  virtual UBool visible(void) const;
1093 
1097  virtual const UnicodeString * getSupportedIDs(int32_t &count, UErrorCode& status) const;
1098 };
1099 #endif /* #if !UCONFIG_NO_SERVICE */
1100 
1101 // -------------------------------------
1102 
1103 inline UBool
1104 NumberFormat::isParseIntegerOnly() const
1105 {
1106  return fParseIntegerOnly;
1107 }
1108 
1109 inline UBool
1110 NumberFormat::isLenient() const
1111 {
1112  return fLenient;
1113 }
1114 
1115 inline UnicodeString&
1116 NumberFormat::format(const Formattable& obj,
1117  UnicodeString& appendTo,
1118  UErrorCode& status) const {
1119  return Format::format(obj, appendTo, status);
1120 }
1121 
1123 
1124 #endif /* #if !UCONFIG_NO_FORMATTING */
1125 
1126 #endif // _NUMFMT
1127 //eof
Base class for all formats.
Definition: format.h:94
UnicodeString _id
The locale supported by this factory, as a UnicodeString.
Definition: numfmt.h:1076
const UBool _visible
True if the locale supported by this factory is visible.
Definition: numfmt.h:1070
EAlignmentFields
Alignment Field constants used to construct a FieldPosition object.
Definition: numfmt.h:183
Abstract base class for all number formats.
Definition: numfmt.h:166
virtual const UnicodeString * getSupportedIDs(int32_t &count, UErrorCode &status) const =0
Return the locale names directly supported by this factory.
virtual UClassID getDynamicClassID() const =0
ICU4C "poor man's RTTI", returns a UClassID for the actual ICU class.
C++ API: Unicode String.
void * UClassID
UClassID is used to identify classes without using the compiler's RTTI.
Definition: uobject.h:96
Base class for 'pure' C++ implementations of uenum api.
Definition: strenum.h:55
C++ API: Base class for all formats.
virtual UBool visible(void) const =0
Return true if this factory will be visible.
#define U_I18N_API
Set to export library symbols from inside the i18n library, and to import them from outside...
Definition: utypes.h:358
C++ API: StringPiece: Read-only byte string wrapper class.
C++ API: Currency Amount Object.
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:129
A NumberFormatFactory that supports a single locale.
Definition: numfmt.h:1064
UNumberFormatStyle
The possible number format styles.
Definition: unum.h:135
A NumberFormatFactory is used to register new number formats.
Definition: numfmt.h:1026
FieldPositionIterator returns the field ids and their start/limit positions generated by a call to Fo...
Definition: fpositer.h:53
UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, UErrorCode &status) const
Formats an object to produce a string.
#define TRUE
The TRUE value of a UBool.
Definition: umachine.h:204
const void * URegistryKey
Opaque type returned by registerInstance, registerFactory and unregister for service registration...
Definition: umisc.h:55
uint16_t UChar
Define UChar to be UCHAR_TYPE, if that is #defined (for example, to char16_t), or wchar_t if that is ...
Definition: umachine.h:278
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:130
UErrorCode
Error code to replace exception handling, so that the code is compatible with all C++ compilers...
Definition: utypes.h:476
FieldPosition is a simple class used by Format and its subclasses to identify fields in formatted out...
Definition: fieldpos.h:106
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.
virtual UBool operator==(const Format &other) const =0
Return true if the given Format objects are semantically equal.
virtual void parseObject(const UnicodeString &source, Formattable &result, ParsePosition &parse_pos) const =0
Parse a string to produce an object.
Basic definitions for ICU, for both C and C++ APIs.
Format & operator=(const Format &)
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:246
Formattable objects can be passed to the Format class or its subclasses for formatting.
Definition: fmtable.h:62
A string-like object that points to a sized piece of memory.
Definition: stringpiece.h:52
UObject is the common ICU "boilerplate" class.
Definition: uobject.h:229
A currency together with a numeric amount, such as 200 USD.
Definition: curramt.h:35
int8_t UBool
The ICU boolean type.
Definition: umachine.h:200
C API: NumberFormat.
A Locale object represents a specific geographical, political, or cultural region.
Definition: locid.h:182