ICU 4.8.1.1  4.8.1.1
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
numfmt.h
Go to the documentation of this file.
1 /*
2 ********************************************************************************
3 * Copyright (C) 1997-2011, 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 
40 class NumberFormatTest;
41 
43 
44 #if !UCONFIG_NO_SERVICE
46 class StringEnumeration;
47 #endif
48 
166 public:
180  kIntegerField,
181  kFractionField,
182  kDecimalSeparatorField,
183  kExponentSymbolField,
184  kExponentSignField,
185  kExponentField,
186  kGroupingSeparatorField,
187  kCurrencyField,
188  kPercentField,
189  kPermillField,
190  kSignField,
191 
197  INTEGER_FIELD = kIntegerField,
198  FRACTION_FIELD = kFractionField
199  };
200 
205  virtual ~NumberFormat();
206 
213  virtual UBool operator==(const Format& other) const;
214 
215 
216  using Format::format;
217 
233  virtual UnicodeString& format(const Formattable& obj,
234  UnicodeString& appendTo,
235  FieldPosition& pos,
236  UErrorCode& status) const;
237 
254  virtual UnicodeString& format(const Formattable& obj,
255  UnicodeString& appendTo,
256  FieldPositionIterator* posIter,
257  UErrorCode& status) const;
258 
287  virtual void parseObject(const UnicodeString& source,
288  Formattable& result,
289  ParsePosition& parse_pos) const;
290 
301  UnicodeString& format( double number,
302  UnicodeString& appendTo) const;
303 
314  UnicodeString& format( int32_t number,
315  UnicodeString& appendTo) const;
316 
327  UnicodeString& format( int64_t number,
328  UnicodeString& appendTo) const;
329 
342  virtual UnicodeString& format(double number,
343  UnicodeString& appendTo,
344  FieldPosition& pos) const = 0;
359  virtual UnicodeString& format(double number,
360  UnicodeString& appendTo,
361  FieldPositionIterator* posIter,
362  UErrorCode& status) const;
375  virtual UnicodeString& format(int32_t number,
376  UnicodeString& appendTo,
377  FieldPosition& pos) const = 0;
378 
393  virtual UnicodeString& format(int32_t number,
394  UnicodeString& appendTo,
395  FieldPositionIterator* posIter,
396  UErrorCode& status) const;
410  virtual UnicodeString& format(int64_t number,
411  UnicodeString& appendTo,
412  FieldPosition& pos) const;
427  virtual UnicodeString& format(int64_t number,
428  UnicodeString& appendTo,
429  FieldPositionIterator* posIter,
430  UErrorCode& status) const;
431 
448  virtual UnicodeString& format(const StringPiece &number,
449  UnicodeString& appendTo,
450  FieldPositionIterator* posIter,
451  UErrorCode& status) const;
452 public:
470  virtual UnicodeString& format(const DigitList &number,
471  UnicodeString& appendTo,
472  FieldPositionIterator* posIter,
473  UErrorCode& status) const;
474 
492  virtual UnicodeString& format(const DigitList &number,
493  UnicodeString& appendTo,
494  FieldPosition& pos,
495  UErrorCode& status) const;
496 
497 public:
498 
509  UnicodeString& format(const Formattable& obj,
510  UnicodeString& appendTo,
511  UErrorCode& status) const;
512 
534  virtual void parse(const UnicodeString& text,
535  Formattable& result,
536  ParsePosition& parsePosition) const = 0;
537 
553  virtual void parse( const UnicodeString& text,
554  Formattable& result,
555  UErrorCode& status) const;
556 
576  virtual Formattable& parseCurrency(const UnicodeString& text,
577  Formattable& result,
578  ParsePosition& pos) const;
579 
591  UBool isParseIntegerOnly(void) const;
592 
600  virtual void setParseIntegerOnly(UBool value);
601 
609  virtual void setLenient(UBool enable);
610 
619  virtual UBool isLenient(void) const;
620 
629  static NumberFormat* U_EXPORT2 createInstance(UErrorCode&);
630 
639  static NumberFormat* U_EXPORT2 createInstance(const Locale& inLocale,
640  UErrorCode&);
641 
650  static NumberFormat* U_EXPORT2 createInstance(const Locale& desiredLocale,
651  UNumberFormatStyle style,
652  UErrorCode& errorCode);
653 
654 
659  static NumberFormat* U_EXPORT2 createCurrencyInstance(UErrorCode&);
660 
666  static NumberFormat* U_EXPORT2 createCurrencyInstance(const Locale& inLocale,
667  UErrorCode&);
668 
673  static NumberFormat* U_EXPORT2 createPercentInstance(UErrorCode&);
674 
680  static NumberFormat* U_EXPORT2 createPercentInstance(const Locale& inLocale,
681  UErrorCode&);
682 
687  static NumberFormat* U_EXPORT2 createScientificInstance(UErrorCode&);
688 
694  static NumberFormat* U_EXPORT2 createScientificInstance(const Locale& inLocale,
695  UErrorCode&);
696 
702  static const Locale* U_EXPORT2 getAvailableLocales(int32_t& count);
703 
704 #if !UCONFIG_NO_SERVICE
705 
712  static URegistryKey U_EXPORT2 registerFactory(NumberFormatFactory* toAdopt, UErrorCode& status);
713 
723  static UBool U_EXPORT2 unregister(URegistryKey key, UErrorCode& status);
724 
731  static StringEnumeration* U_EXPORT2 getAvailableLocales(void);
732 #endif /* UCONFIG_NO_SERVICE */
733 
743  UBool isGroupingUsed(void) const;
744 
751  virtual void setGroupingUsed(UBool newValue);
752 
761  int32_t getMaximumIntegerDigits(void) const;
762 
775  virtual void setMaximumIntegerDigits(int32_t newValue);
776 
785  int32_t getMinimumIntegerDigits(void) const;
786 
797  virtual void setMinimumIntegerDigits(int32_t newValue);
798 
807  int32_t getMaximumFractionDigits(void) const;
808 
819  virtual void setMaximumFractionDigits(int32_t newValue);
820 
829  int32_t getMinimumFractionDigits(void) const;
830 
841  virtual void setMinimumFractionDigits(int32_t newValue);
842 
855  virtual void setCurrency(const UChar* theCurrency, UErrorCode& ec);
856 
864  const UChar* getCurrency() const;
865 
866 public:
867 
876  static UClassID U_EXPORT2 getStaticClassID(void);
877 
889  virtual UClassID getDynamicClassID(void) const = 0;
890 
891 protected:
892 
897  NumberFormat();
898 
903  NumberFormat(const NumberFormat&);
904 
910 
919  virtual void getEffectiveCurrency(UChar* result, UErrorCode& ec) const;
920 
921 private:
922 
923  static UBool isStyleSupported(UNumberFormatStyle style);
924 
932  static NumberFormat* makeInstance(const Locale& desiredLocale,
933  UNumberFormatStyle style,
934  UErrorCode& errorCode);
935 
936  UBool fGroupingUsed;
937  int32_t fMaxIntegerDigits;
938  int32_t fMinIntegerDigits;
939  int32_t fMaxFractionDigits;
940  int32_t fMinFractionDigits;
941  UBool fParseIntegerOnly;
942  UBool fLenient; // TRUE => lenient parse is enabled
943 
944  // ISO currency code
945  UChar fCurrency[4];
946 
947  friend class ICUNumberFormatFactory; // access to makeInstance
948  friend class ICUNumberFormatService;
949  friend class ::NumberFormatTest; // access to isStyleSupported()
950 };
951 
952 #if !UCONFIG_NO_SERVICE
953 
962 public:
963 
968  virtual ~NumberFormatFactory();
969 
976  virtual UBool visible(void) const = 0;
977 
983  virtual const UnicodeString * getSupportedIDs(int32_t &count, UErrorCode& status) const = 0;
984 
992  virtual NumberFormat* createFormat(const Locale& loc, UNumberFormatStyle formatType) = 0;
993 };
994 
1000 protected:
1006 
1012 
1013 public:
1017  SimpleNumberFormatFactory(const Locale& locale, UBool visible = TRUE);
1018 
1022  virtual ~SimpleNumberFormatFactory();
1023 
1027  virtual UBool visible(void) const;
1028 
1032  virtual const UnicodeString * getSupportedIDs(int32_t &count, UErrorCode& status) const;
1033 };
1034 #endif /* #if !UCONFIG_NO_SERVICE */
1035 
1036 // -------------------------------------
1037 
1038 inline UBool
1040 {
1041  return fParseIntegerOnly;
1042 }
1043 
1044 inline UBool
1046 {
1047  return fLenient;
1048 }
1049 
1050 inline UnicodeString&
1052  UnicodeString& appendTo,
1053  UErrorCode& status) const {
1054  return Format::format(obj, appendTo, status);
1055 }
1056 
1058 
1059 #endif /* #if !UCONFIG_NO_FORMATTING */
1060 
1061 #endif // _NUMFMT
1062 //eof
const UBool _visible
True if the locale supported by this factory is visible.
Definition: numfmt.h:1005
virtual UBool isLenient(void) const
Returns whether lenient parsing is enabled (it is off by default).
Definition: numfmt.h:1045
A string-like object that points to a sized piece of memory.
Definition: stringpiece.h:52
virtual void parseObject(const UnicodeString &source, Formattable &result, ParsePosition &parse_pos) const =0
Parse a string to produce an object.
C++ API: Unicode String.
UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, UErrorCode &status) const
Formats an object to produce a string.
C++ API: Base class for all formats.
virtual const UnicodeString * getSupportedIDs(int32_t &count, UErrorCode &status) const =0
Return the locale names directly supported by this factory.
#define U_I18N_API
Set to export library symbols from inside the i18n library, and to import them from outside...
Definition: utypes.h:521
C++ API: StringPiece: Read-only byte string wrapper class.
#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
UNumberFormatStyle
The possible number format styles.
Definition: unum.h:135
UBool isParseIntegerOnly(void) const
Return true if this format will parse numbers as integers only.
Definition: numfmt.h:1039
ParsePosition is a simple class used by Format and its subclasses to keep track of the current positi...
Definition: parsepos.h:47
A NumberFormatFactory is used to register new number formats.
Definition: numfmt.h:961
virtual UBool operator==(const Format &other) const =0
Return true if the given Format objects are semantically equal.
#define TRUE
The TRUE value of a UBool.
Definition: umachine.h:232
A NumberFormatFactory that supports a single locale.
Definition: numfmt.h:999
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
FieldPositionIterator returns the field ids and their start/limit positions generated by a call to Fo...
Definition: fpositer.h:53
UnicodeString _id
The locale supported by this factory, as a UnicodeString.
Definition: numfmt.h:1011
virtual UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const
Format an object to produce a string.
const void * URegistryKey
Opaque type returned by registerInstance, registerFactory and unregister for service registration...
Definition: umisc.h:55
FieldPosition is a simple class used by Format and its subclasses to identify fields in formatted out...
Definition: fieldpos.h:106
uint16_t UChar
Define UChar to be wchar_t if that is 16 bits wide; always assumed to be unsigned.
Definition: umachine.h:325
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:132
UObject is the common ICU "boilerplate" class.
Definition: uobject.h:215
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
Base class for 'pure' C++ implementations of uenum api.
Definition: strenum.h:55
EAlignmentFields
Alignment Field constants used to construct a FieldPosition object.
Definition: numfmt.h:179
C++ API: Locale ID object.
Base class for all formats.
Definition: format.h:94
Basic definitions for ICU, for both C and C++ APIs.
A Locale object represents a specific geographical, political, or cultural region.
Definition: locid.h:181
virtual UBool visible(void) const =0
Return true if this factory will be visible.
virtual UClassID getDynamicClassID() const =0
ICU4C "poor man's RTTI", returns a UClassID for the actual ICU class.
int8_t UBool
The ICU boolean type.
Definition: umachine.h:228
C API: NumberFormat.
Format & operator=(const Format &)