icuSources/i18n/digitformatter.h

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2015, International Business Machines
   4 * Corporation and others.  All Rights Reserved.
   5 *******************************************************************************
   6 * digitformatter.h
   7 *
   8 * created on: 2015jan06
   9 * created by: Travis Keep
  10 */
  11
  12 #ifndef __DIGITFORMATTER_H__
  13 #define __DIGITFORMATTER_H__
  14
  15 #include "unicode/uobject.h"
  16
  17 #if !UCONFIG_NO_FORMATTING
  18
  19 #include "unicode/utypes.h"
  20 #include "unicode/unistr.h"
  21 #include "digitaffix.h"
  22
  23 U_NAMESPACE_BEGIN
  24
  25 class DecimalFormatSymbols;
  26 class DigitList;
  27 class DigitGrouping;
  28 class DigitInterval;
  29 class UnicodeString;
  30 class FieldPositionHandler;
  31 class IntDigitCountRange;
  32 class VisibleDigits;
  33 class VisibleDigitsWithExponent;
  34
  35 /**
  36  * Various options for formatting in fixed point.
  37  */
  38 class U_I18N_API DigitFormatterOptions : public UMemory {
  39     public:
  40     DigitFormatterOptions() : fAlwaysShowDecimal(FALSE) { }
  41
  42     /**
  43      * Returns TRUE if this object equals rhs.
  44      */
  45     UBool equals(const DigitFormatterOptions &rhs) const {
  46         return (
  47             fAlwaysShowDecimal == rhs.fAlwaysShowDecimal);
  48     }
  49
  50     /**
  51      * Returns TRUE if these options allow for fast formatting of
  52      * integers.
  53      */
  54     UBool isFastFormattable() const {
  55         return (fAlwaysShowDecimal == FALSE);
  56     }
  57
  58     /**
  59      * If TRUE, show the decimal separator even when there are no fraction
  60      * digits. default is FALSE.
  61      */
  62     UBool fAlwaysShowDecimal;
  63 };
  64
  65 /**
  66  * Various options for formatting an integer.
  67  */
  68 class U_I18N_API DigitFormatterIntOptions : public UMemory {
  69     public:
  70     DigitFormatterIntOptions() : fAlwaysShowSign(FALSE) { }
  71
  72     /**
  73      * Returns TRUE if this object equals rhs.
  74      */
  75     UBool equals(const DigitFormatterIntOptions &rhs) const {
  76         return (fAlwaysShowSign == rhs.fAlwaysShowSign);
  77     }
  78
  79     /**
  80      * If TRUE, always prefix the integer with its sign even if the number is
  81      * positive. Default is FALSE.
  82      */
  83     UBool fAlwaysShowSign;
  84 };
  85
  86 /**
  87  * Options for formatting in scientific notation.
  88  */
  89 class U_I18N_API SciFormatterOptions : public UMemory {
  90     public:
  91
  92     /**
  93      * Returns TRUE if this object equals rhs.
  94      */
  95     UBool equals(const SciFormatterOptions &rhs) const {
  96         return (fMantissa.equals(rhs.fMantissa) &&
  97                 fExponent.equals(rhs.fExponent));
  98     }
  99
 100     /**
 101      * Options for formatting the mantissa.
 102      */
 103     DigitFormatterOptions fMantissa;
 104
 105     /**
 106      * Options for formatting the exponent.
 107      */
 108     DigitFormatterIntOptions fExponent;
 109 };
 110
 111
 112 /**
 113  * Does fixed point formatting.
 114  *
 115  * This class only does fixed point formatting. It does no rounding before
 116  * formatting.
 117  */
 118 class U_I18N_API DigitFormatter : public UMemory {
 119 public:
 120
 121 /**
 122  * Decimal separator is period (.), Plus sign is plus (+),
 123  * minus sign is minus (-), grouping separator is comma (,), digits are 0-9.
 124  */
 125 DigitFormatter();
 126
 127 /**
 128  * Let symbols determine the digits, decimal separator,
 129  * plus and mius sign, grouping separator, and possibly other settings.
 130  */
 131 DigitFormatter(const DecimalFormatSymbols &symbols);
 132
 133 /**
 134  * Change what this instance uses for digits, decimal separator,
 135  * plus and mius sign, grouping separator, and possibly other settings
 136  * according to symbols.
 137  */
 138 void setDecimalFormatSymbols(const DecimalFormatSymbols &symbols);
 139
 140 /**
 141  * Change what this instance uses for digits, decimal separator,
 142  * plus and mius sign, grouping separator, and possibly other settings
 143  * according to symbols in the context of monetary amounts.
 144  */
 145 void setDecimalFormatSymbolsForMonetary(const DecimalFormatSymbols &symbols);
 146
 147 /**
 148  * Fixed point formatting.
 149  *
 150  * @param positiveDigits the value to format
 151  *  Negative sign can be present, but it won't show.
 152  * @param grouping controls how digit grouping is done
 153  * @param options formatting options
 154  * @param handler records field positions
 155  * @param appendTo formatted value appended here.
 156  * @return appendTo
 157  */
 158 UnicodeString &format(
 159         const VisibleDigits &positiveDigits,
 160         const DigitGrouping &grouping,
 161         const DigitFormatterOptions &options,
 162         FieldPositionHandler &handler,
 163         UnicodeString &appendTo) const;
 164
 165 /**
 166  * formats in scientifc notation.
 167  * @param positiveDigits the value to format.
 168  *  Negative sign can be present, but it won't show.
 169  * @param options formatting options
 170  * @param handler records field positions.
 171  * @param appendTo formatted value appended here.
 172  */
 173 UnicodeString &format(
 174         const VisibleDigitsWithExponent &positiveDigits,
 175         const SciFormatterOptions &options,
 176         FieldPositionHandler &handler,
 177         UnicodeString &appendTo) const;
 178
 179 /**
 180  * Fixed point formatting of integers.
 181  * Always performed with no grouping and no decimal point.
 182  *
 183  * @param positiveValue the value to format must be positive.
 184  * @param range specifies minimum and maximum number of digits.
 185  * @param handler records field positions
 186  * @param appendTo formatted value appended here.
 187  * @return appendTo
 188  */
 189 UnicodeString &formatPositiveInt32(
 190         int32_t positiveValue,
 191         const IntDigitCountRange &range,
 192         FieldPositionHandler &handler,
 193         UnicodeString &appendTo) const;
 194
 195 /**
 196  * Counts how many code points are needed for fixed formatting.
 197  *   If digits is negative, the negative sign is not included in the count.
 198  */
 199 int32_t countChar32(
 200         const VisibleDigits &digits,
 201         const DigitGrouping &grouping,
 202         const DigitFormatterOptions &options) const;
 203
 204 /**
 205  * Counts how many code points are needed for scientific formatting.
 206  *   If digits is negative, the negative sign is not included in the count.
 207  */
 208 int32_t countChar32(
 209         const VisibleDigitsWithExponent &digits,
 210         const SciFormatterOptions &options) const;
 211
 212 /**
 213  * Returns TRUE if this object equals rhs.
 214  */
 215 UBool equals(const DigitFormatter &rhs) const;
 216
 217 private:
 218 UChar32 fLocalizedDigits[10];
 219 UnicodeString fGroupingSeparator;
 220 UnicodeString fDecimal;
 221 UnicodeString fNegativeSign;
 222 UnicodeString fPositiveSign;
 223 DigitAffix fInfinity;
 224 DigitAffix fNan;
 225 UBool fIsStandardDigits;
 226 UnicodeString fExponent;
 227 UBool isStandardDigits() const;
 228
 229 UnicodeString &formatDigits(
 230         const uint8_t *digits,
 231         int32_t count,
 232         const IntDigitCountRange &range,
 233         int32_t intField,
 234         FieldPositionHandler &handler,
 235         UnicodeString &appendTo) const;
 236
 237 void setOtherDecimalFormatSymbols(const DecimalFormatSymbols &symbols);
 238
 239 int32_t countChar32(
 240         const VisibleDigits &exponent,
 241         const DigitInterval &mantissaInterval,
 242         const SciFormatterOptions &options) const;
 243
 244 UnicodeString &formatNaN(
 245         FieldPositionHandler &handler,
 246         UnicodeString &appendTo) const {
 247     return fNan.format(handler, appendTo);
 248 }
 249
 250 int32_t countChar32ForNaN() const {
 251     return fNan.toString().countChar32();
 252 }
 253
 254 UnicodeString &formatInfinity(
 255         FieldPositionHandler &handler,
 256         UnicodeString &appendTo) const {
 257     return fInfinity.format(handler, appendTo);
 258 }
 259
 260 int32_t countChar32ForInfinity() const {
 261     return fInfinity.toString().countChar32();
 262 }
 263
 264 UnicodeString &formatExponent(
 265         const VisibleDigits &digits,
 266         const DigitFormatterIntOptions &options,
 267         int32_t signField,
 268         int32_t intField,
 269         FieldPositionHandler &handler,
 270         UnicodeString &appendTo) const;
 271
 272 int32_t countChar32(
 273         const DigitGrouping &grouping,
 274         const DigitInterval &interval,
 275         const DigitFormatterOptions &options) const;
 276
 277 int32_t countChar32ForExponent(
 278         const VisibleDigits &exponent,
 279         const DigitFormatterIntOptions &options) const;
 280
 281 };
 282
 283
 284 U_NAMESPACE_END
 285 #endif /* #if !UCONFIG_NO_FORMATTING */
 286 #endif  // __DIGITFORMATTER_H__