icuSources/i18n/unicode/fmtable.h

   1 /*
   2 ********************************************************************************
   3 *   Copyright (C) 1997-2014, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 ********************************************************************************
   6 *
   7 * File FMTABLE.H
   8 *
   9 * Modification History:
  10 *
  11 *   Date        Name        Description
  12 *   02/29/97    aliu        Creation.
  13 ********************************************************************************
  14 */
  15 #ifndef FMTABLE_H
  16 #define FMTABLE_H
  17
  18 #include "unicode/utypes.h"
  19
  20 /**
  21  * \file
  22  * \brief C++ API: Formattable is a thin wrapper for primitive types used for formatting and parsing
  23  */
  24
  25 #if !UCONFIG_NO_FORMATTING
  26
  27 #include "unicode/unistr.h"
  28 #include "unicode/stringpiece.h"
  29 #include "unicode/uformattable.h"
  30
  31 U_NAMESPACE_BEGIN
  32
  33 class CharString;
  34 class DigitList;
  35
  36 /**
  37  * \def UNUM_INTERNAL_STACKARRAY_SIZE
  38  * @internal
  39  */
  40 #if U_PLATFORM == U_PF_OS400
  41 #define UNUM_INTERNAL_STACKARRAY_SIZE 144
  42 #else
  43 #define UNUM_INTERNAL_STACKARRAY_SIZE 128
  44 #endif
  45
  46 /**
  47  * Formattable objects can be passed to the Format class or
  48  * its subclasses for formatting.  Formattable is a thin wrapper
  49  * class which interconverts between the primitive numeric types
  50  * (double, long, etc.) as well as UDate and UnicodeString.
  51  *
  52  * <p>Internally, a Formattable object is a union of primitive types.
  53  * As such, it can only store one flavor of data at a time.  To
  54  * determine what flavor of data it contains, use the getType method.
  55  *
  56  * <p>As of ICU 3.0, Formattable may also wrap a UObject pointer,
  57  * which it owns.  This allows an instance of any ICU class to be
  58  * encapsulated in a Formattable.  For legacy reasons and for
  59  * efficiency, primitive numeric types are still stored directly
  60  * within a Formattable.
  61  *
  62  * <p>The Formattable class is not suitable for subclassing.
  63  *
  64  * <p>See UFormattable for a C wrapper.
  65  */
  66 class U_I18N_API Formattable : public UObject {
  67 public:
  68     /**
  69      * This enum is only used to let callers distinguish between
  70      * the Formattable(UDate) constructor and the Formattable(double)
  71      * constructor; the compiler cannot distinguish the signatures,
  72      * since UDate is currently typedefed to be either double or long.
  73      * If UDate is changed later to be a bonafide class
  74      * or struct, then we no longer need this enum.
  75      * @stable ICU 2.4
  76      */
  77     enum ISDATE { kIsDate };
  78
  79     /**
  80      * Default constructor
  81      * @stable ICU 2.4
  82      */
  83     Formattable(); // Type kLong, value 0
  84
  85     /**
  86      * Creates a Formattable object with a UDate instance.
  87      * @param d the UDate instance.
  88      * @param flag the flag to indicate this is a date. Always set it to kIsDate
  89      * @stable ICU 2.0
  90      */
  91     Formattable(UDate d, ISDATE flag);
  92
  93     /**
  94      * Creates a Formattable object with a double number.
  95      * @param d the double number.
  96      * @stable ICU 2.0
  97      */
  98     Formattable(double d);
  99
 100     /**
 101      * Creates a Formattable object with a long number.
 102      * @param l the long number.
 103      * @stable ICU 2.0
 104      */
 105     Formattable(int32_t l);
 106
 107     /**
 108      * Creates a Formattable object with an int64_t number
 109      * @param ll the int64_t number.
 110      * @stable ICU 2.8
 111      */
 112     Formattable(int64_t ll);
 113
 114 #if !UCONFIG_NO_CONVERSION
 115     /**
 116      * Creates a Formattable object with a char string pointer.
 117      * Assumes that the char string is null terminated.
 118      * @param strToCopy the char string.
 119      * @stable ICU 2.0
 120      */
 121     Formattable(const char* strToCopy);
 122 #endif
 123
 124     /**
 125      * Creates a Formattable object of an appropriate numeric type from a
 126      * a decimal number in string form.  The Formattable will retain the
 127      * full precision of the input in decimal format, even when it exceeds
 128      * what can be represented by a double or int64_t.
 129      *
 130      * @param number  the unformatted (not localized) string representation
 131      *                     of the Decimal number.
 132      * @param status  the error code.  Possible errors include U_INVALID_FORMAT_ERROR
 133      *                if the format of the string does not conform to that of a
 134      *                decimal number.
 135      * @stable ICU 4.4
 136      */
 137     Formattable(const StringPiece &number, UErrorCode &status);
 138
 139     /**
 140      * Creates a Formattable object with a UnicodeString object to copy from.
 141      * @param strToCopy the UnicodeString string.
 142      * @stable ICU 2.0
 143      */
 144     Formattable(const UnicodeString& strToCopy);
 145
 146     /**
 147      * Creates a Formattable object with a UnicodeString object to adopt from.
 148      * @param strToAdopt the UnicodeString string.
 149      * @stable ICU 2.0
 150      */
 151     Formattable(UnicodeString* strToAdopt);
 152
 153     /**
 154      * Creates a Formattable object with an array of Formattable objects.
 155      * @param arrayToCopy the Formattable object array.
 156      * @param count the array count.
 157      * @stable ICU 2.0
 158      */
 159     Formattable(const Formattable* arrayToCopy, int32_t count);
 160
 161     /**
 162      * Creates a Formattable object that adopts the given UObject.
 163      * @param objectToAdopt the UObject to set this object to
 164      * @stable ICU 3.0
 165      */
 166     Formattable(UObject* objectToAdopt);
 167
 168     /**
 169      * Copy constructor.
 170      * @stable ICU 2.0
 171      */
 172     Formattable(const Formattable&);
 173
 174     /**
 175      * Assignment operator.
 176      * @param rhs   The Formattable object to copy into this object.
 177      * @stable ICU 2.0
 178      */
 179     Formattable&    operator=(const Formattable &rhs);
 180
 181     /**
 182      * Equality comparison.
 183      * @param other    the object to be compared with.
 184      * @return        TRUE if other are equal to this, FALSE otherwise.
 185      * @stable ICU 2.0
 186      */
 187     UBool          operator==(const Formattable &other) const;
 188
 189     /**
 190      * Equality operator.
 191      * @param other    the object to be compared with.
 192      * @return        TRUE if other are unequal to this, FALSE otherwise.
 193      * @stable ICU 2.0
 194      */
 195     UBool          operator!=(const Formattable& other) const
 196       { return !operator==(other); }
 197
 198     /**
 199      * Destructor.
 200      * @stable ICU 2.0
 201      */
 202     virtual         ~Formattable();
 203
 204     /**
 205      * Clone this object.
 206      * Clones can be used concurrently in multiple threads.
 207      * If an error occurs, then NULL is returned.
 208      * The caller must delete the clone.
 209      *
 210      * @return a clone of this object
 211      *
 212      * @see getDynamicClassID
 213      * @stable ICU 2.8
 214      */
 215     Formattable *clone() const;
 216
 217     /**
 218      * Selector for flavor of data type contained within a
 219      * Formattable object.  Formattable is a union of several
 220      * different types, and at any time contains exactly one type.
 221      * @stable ICU 2.4
 222      */
 223     enum Type {
 224         /**
 225          * Selector indicating a UDate value.  Use getDate to retrieve
 226          * the value.
 227          * @stable ICU 2.4
 228          */
 229         kDate,
 230
 231         /**
 232          * Selector indicating a double value.  Use getDouble to
 233          * retrieve the value.
 234          * @stable ICU 2.4
 235          */
 236         kDouble,
 237
 238         /**
 239          * Selector indicating a 32-bit integer value.  Use getLong to
 240          * retrieve the value.
 241          * @stable ICU 2.4
 242          */
 243         kLong,
 244
 245         /**
 246          * Selector indicating a UnicodeString value.  Use getString
 247          * to retrieve the value.
 248          * @stable ICU 2.4
 249          */
 250         kString,
 251
 252         /**
 253          * Selector indicating an array of Formattables.  Use getArray
 254          * to retrieve the value.
 255          * @stable ICU 2.4
 256          */
 257         kArray,
 258
 259         /**
 260          * Selector indicating a 64-bit integer value.  Use getInt64
 261          * to retrieve the value.
 262          * @stable ICU 2.8
 263          */
 264         kInt64,
 265
 266         /**
 267          * Selector indicating a UObject value.  Use getObject to
 268          * retrieve the value.
 269          * @stable ICU 3.0
 270          */
 271         kObject
 272    };
 273
 274     /**
 275      * Gets the data type of this Formattable object.
 276      * @return    the data type of this Formattable object.
 277      * @stable ICU 2.0
 278      */
 279     Type            getType(void) const;
 280
 281     /**
 282      * Returns TRUE if the data type of this Formattable object
 283      * is kDouble, kLong, or kInt64
 284      * @return TRUE if this is a pure numeric object
 285      * @stable ICU 3.0
 286      */
 287     UBool           isNumeric() const;
 288
 289     /**
 290      * Gets the double value of this object. If this object is not of type
 291      * kDouble then the result is undefined.
 292      * @return    the double value of this object.
 293      * @stable ICU 2.0
 294      */
 295     double          getDouble(void) const { return fValue.fDouble; }
 296
 297     /**
 298      * Gets the double value of this object. If this object is of type
 299      * long, int64 or Decimal Number then a conversion is peformed, with
 300      * possible loss of precision.  If the type is kObject and the
 301      * object is a Measure, then the result of
 302      * getNumber().getDouble(status) is returned.  If this object is
 303      * neither a numeric type nor a Measure, then 0 is returned and
 304      * the status is set to U_INVALID_FORMAT_ERROR.
 305      * @param status the error code
 306      * @return the double value of this object.
 307      * @stable ICU 3.0
 308      */
 309     double          getDouble(UErrorCode& status) const;
 310
 311     /**
 312      * Gets the long value of this object. If this object is not of type
 313      * kLong then the result is undefined.
 314      * @return    the long value of this object.
 315      * @stable ICU 2.0
 316      */
 317     int32_t         getLong(void) const { return (int32_t)fValue.fInt64; }
 318
 319     /**
 320      * Gets the long value of this object. If the magnitude is too
 321      * large to fit in a long, then the maximum or minimum long value,
 322      * as appropriate, is returned and the status is set to
 323      * U_INVALID_FORMAT_ERROR.  If this object is of type kInt64 and
 324      * it fits within a long, then no precision is lost.  If it is of
 325      * type kDouble, then a conversion is peformed, with
 326      * truncation of any fractional part.  If the type is kObject and
 327      * the object is a Measure, then the result of
 328      * getNumber().getLong(status) is returned.  If this object is
 329      * neither a numeric type nor a Measure, then 0 is returned and
 330      * the status is set to U_INVALID_FORMAT_ERROR.
 331      * @param status the error code
 332      * @return    the long value of this object.
 333      * @stable ICU 3.0
 334      */
 335     int32_t         getLong(UErrorCode& status) const;
 336
 337     /**
 338      * Gets the int64 value of this object. If this object is not of type
 339      * kInt64 then the result is undefined.
 340      * @return    the int64 value of this object.
 341      * @stable ICU 2.8
 342      */
 343     int64_t         getInt64(void) const { return fValue.fInt64; }
 344
 345     /**
 346      * Gets the int64 value of this object. If this object is of a numeric
 347      * type and the magnitude is too large to fit in an int64, then
 348      * the maximum or minimum int64 value, as appropriate, is returned
 349      * and the status is set to U_INVALID_FORMAT_ERROR.  If the
 350      * magnitude fits in an int64, then a casting conversion is
 351      * peformed, with truncation of any fractional part.  If the type
 352      * is kObject and the object is a Measure, then the result of
 353      * getNumber().getDouble(status) is returned.  If this object is
 354      * neither a numeric type nor a Measure, then 0 is returned and
 355      * the status is set to U_INVALID_FORMAT_ERROR.
 356      * @param status the error code
 357      * @return    the int64 value of this object.
 358      * @stable ICU 3.0
 359      */
 360     int64_t         getInt64(UErrorCode& status) const;
 361
 362     /**
 363      * Gets the Date value of this object. If this object is not of type
 364      * kDate then the result is undefined.
 365      * @return    the Date value of this object.
 366      * @stable ICU 2.0
 367      */
 368     UDate           getDate() const { return fValue.fDate; }
 369
 370     /**
 371      * Gets the Date value of this object.  If the type is not a date,
 372      * status is set to U_INVALID_FORMAT_ERROR and the return value is
 373      * undefined.
 374      * @param status the error code.
 375      * @return    the Date value of this object.
 376      * @stable ICU 3.0
 377      */
 378      UDate          getDate(UErrorCode& status) const;
 379
 380     /**
 381      * Gets the string value of this object. If this object is not of type
 382      * kString then the result is undefined.
 383      * @param result    Output param to receive the Date value of this object.
 384      * @return          A reference to 'result'.
 385      * @stable ICU 2.0
 386      */
 387     UnicodeString&  getString(UnicodeString& result) const
 388       { result=*fValue.fString; return result; }
 389
 390     /**
 391      * Gets the string value of this object. If the type is not a
 392      * string, status is set to U_INVALID_FORMAT_ERROR and a bogus
 393      * string is returned.
 394      * @param result    Output param to receive the Date value of this object.
 395      * @param status    the error code.
 396      * @return          A reference to 'result'.
 397      * @stable ICU 3.0
 398      */
 399     UnicodeString&  getString(UnicodeString& result, UErrorCode& status) const;
 400
 401     /**
 402      * Gets a const reference to the string value of this object. If
 403      * this object is not of type kString then the result is
 404      * undefined.
 405      * @return   a const reference to the string value of this object.
 406      * @stable ICU 2.0
 407      */
 408     inline const UnicodeString& getString(void) const;
 409
 410     /**
 411      * Gets a const reference to the string value of this object.  If
 412      * the type is not a string, status is set to
 413      * U_INVALID_FORMAT_ERROR and the result is a bogus string.
 414      * @param status    the error code.
 415      * @return   a const reference to the string value of this object.
 416      * @stable ICU 3.0
 417      */
 418     const UnicodeString& getString(UErrorCode& status) const;
 419
 420     /**
 421      * Gets a reference to the string value of this object. If this
 422      * object is not of type kString then the result is undefined.
 423      * @return   a reference to the string value of this object.
 424      * @stable ICU 2.0
 425      */
 426     inline UnicodeString& getString(void);
 427
 428     /**
 429      * Gets a reference to the string value of this object. If the
 430      * type is not a string, status is set to U_INVALID_FORMAT_ERROR
 431      * and the result is a bogus string.
 432      * @param status    the error code.
 433      * @return   a reference to the string value of this object.
 434      * @stable ICU 3.0
 435      */
 436     UnicodeString& getString(UErrorCode& status);
 437
 438     /**
 439      * Gets the array value and count of this object. If this object
 440      * is not of type kArray then the result is undefined.
 441      * @param count    fill-in with the count of this object.
 442      * @return         the array value of this object.
 443      * @stable ICU 2.0
 444      */
 445     const Formattable* getArray(int32_t& count) const
 446       { count=fValue.fArrayAndCount.fCount; return fValue.fArrayAndCount.fArray; }
 447
 448     /**
 449      * Gets the array value and count of this object. If the type is
 450      * not an array, status is set to U_INVALID_FORMAT_ERROR, count is
 451      * set to 0, and the result is NULL.
 452      * @param count    fill-in with the count of this object.
 453      * @param status the error code.
 454      * @return         the array value of this object.
 455      * @stable ICU 3.0
 456      */
 457     const Formattable* getArray(int32_t& count, UErrorCode& status) const;
 458
 459     /**
 460      * Accesses the specified element in the array value of this
 461      * Formattable object. If this object is not of type kArray then
 462      * the result is undefined.
 463      * @param index the specified index.
 464      * @return the accessed element in the array.
 465      * @stable ICU 2.0
 466      */
 467     Formattable&    operator[](int32_t index) { return fValue.fArrayAndCount.fArray[index]; }
 468
 469     /**
 470      * Returns a pointer to the UObject contained within this
 471      * formattable, or NULL if this object does not contain a UObject.
 472      * @return a UObject pointer, or NULL
 473      * @stable ICU 3.0
 474      */
 475     const UObject*  getObject() const;
 476
 477     /**
 478      * Returns a numeric string representation of the number contained within this
 479      * formattable, or NULL if this object does not contain numeric type.
 480      * For values obtained by parsing, the returned decimal number retains
 481      * the full precision and range of the original input, unconstrained by
 482      * the limits of a double floating point or a 64 bit int.
 483      *
 484      * This function is not thread safe, and therfore is not declared const,
 485      * even though it is logically const.
 486      *
 487      * Possible errors include U_MEMORY_ALLOCATION_ERROR, and
 488      * U_INVALID_STATE if the formattable object has not been set to
 489      * a numeric type.
 490      *
 491      * @param status the error code.
 492      * @return the unformatted string representation of a number.
 493      * @stable ICU 4.4
 494      */
 495     StringPiece getDecimalNumber(UErrorCode &status);
 496
 497      /**
 498      * Sets the double value of this object and changes the type to
 499      * kDouble.
 500      * @param d    the new double value to be set.
 501      * @stable ICU 2.0
 502      */
 503     void            setDouble(double d);
 504
 505     /**
 506      * Sets the long value of this object and changes the type to
 507      * kLong.
 508      * @param l    the new long value to be set.
 509      * @stable ICU 2.0
 510      */
 511     void            setLong(int32_t l);
 512
 513     /**
 514      * Sets the int64 value of this object and changes the type to
 515      * kInt64.
 516      * @param ll    the new int64 value to be set.
 517      * @stable ICU 2.8
 518      */
 519     void            setInt64(int64_t ll);
 520
 521     /**
 522      * Sets the Date value of this object and changes the type to
 523      * kDate.
 524      * @param d    the new Date value to be set.
 525      * @stable ICU 2.0
 526      */
 527     void            setDate(UDate d);
 528
 529     /**
 530      * Sets the string value of this object and changes the type to
 531      * kString.
 532      * @param stringToCopy    the new string value to be set.
 533      * @stable ICU 2.0
 534      */
 535     void            setString(const UnicodeString& stringToCopy);
 536
 537     /**
 538      * Sets the array value and count of this object and changes the
 539      * type to kArray.
 540      * @param array    the array value.
 541      * @param count    the number of array elements to be copied.
 542      * @stable ICU 2.0
 543      */
 544     void            setArray(const Formattable* array, int32_t count);
 545
 546     /**
 547      * Sets and adopts the string value and count of this object and
 548      * changes the type to kArray.
 549      * @param stringToAdopt    the new string value to be adopted.
 550      * @stable ICU 2.0
 551      */
 552     void            adoptString(UnicodeString* stringToAdopt);
 553
 554     /**
 555      * Sets and adopts the array value and count of this object and
 556      * changes the type to kArray.
 557      * @stable ICU 2.0
 558      */
 559     void            adoptArray(Formattable* array, int32_t count);
 560
 561     /**
 562      * Sets and adopts the UObject value of this object and changes
 563      * the type to kObject.  After this call, the caller must not
 564      * delete the given object.
 565      * @param objectToAdopt the UObject value to be adopted
 566      * @stable ICU 3.0
 567      */
 568     void            adoptObject(UObject* objectToAdopt);
 569
 570     /**
 571      * Sets the the numeric value from a decimal number string, and changes
 572      * the type to to a numeric type appropriate for the number.
 573      * The syntax of the number is a "numeric string"
 574      * as defined in the Decimal Arithmetic Specification, available at
 575      * http://speleotrove.com/decimal
 576      * The full precision and range of the input number will be retained,
 577      * even when it exceeds what can be represented by a double or an int64.
 578      *
 579      * @param numberString  a string representation of the unformatted decimal number.
 580      * @param status        the error code.  Set to U_INVALID_FORMAT_ERROR if the
 581      *                      incoming string is not a valid decimal number.
 582      * @stable ICU 4.4
 583      */
 584     void             setDecimalNumber(const StringPiece &numberString,
 585                                       UErrorCode &status);
 586
 587     /**
 588      * ICU "poor man's RTTI", returns a UClassID for the actual class.
 589      *
 590      * @stable ICU 2.2
 591      */
 592     virtual UClassID getDynamicClassID() const;
 593
 594     /**
 595      * ICU "poor man's RTTI", returns a UClassID for this class.
 596      *
 597      * @stable ICU 2.2
 598      */
 599     static UClassID U_EXPORT2 getStaticClassID();
 600
 601     /**
 602      * Convert the UFormattable to a Formattable.  Internally, this is a reinterpret_cast.
 603      * @param fmt a valid UFormattable
 604      * @return the UFormattable as a Formattable object pointer.  This is an alias to the original
 605      * UFormattable, and so is only valid while the original argument remains in scope.
 606      * @stable ICU 52
 607      */
 608     static inline Formattable *fromUFormattable(UFormattable *fmt);
 609
 610     /**
 611      * Convert the const UFormattable to a const Formattable.  Internally, this is a reinterpret_cast.
 612      * @param fmt a valid UFormattable
 613      * @return the UFormattable as a Formattable object pointer.  This is an alias to the original
 614      * UFormattable, and so is only valid while the original argument remains in scope.
 615      * @stable ICU 52
 616      */
 617     static inline const Formattable *fromUFormattable(const UFormattable *fmt);
 618
 619     /**
 620      * Convert this object pointer to a UFormattable.
 621      * @return this object as a UFormattable pointer.   This is an alias to this object,
 622      * and so is only valid while this object remains in scope.
 623      * @stable ICU 52
 624      */
 625     inline UFormattable *toUFormattable();
 626
 627     /**
 628      * Convert this object pointer to a UFormattable.
 629      * @return this object as a UFormattable pointer.   This is an alias to this object,
 630      * and so is only valid while this object remains in scope.
 631      * @stable ICU 52
 632      */
 633     inline const UFormattable *toUFormattable() const;
 634
 635 #ifndef U_HIDE_DEPRECATED_API
 636     /**
 637      * Deprecated variant of getLong(UErrorCode&).
 638      * @param status the error code
 639      * @return the long value of this object.
 640      * @deprecated ICU 3.0 use getLong(UErrorCode&) instead
 641      */
 642     inline int32_t getLong(UErrorCode* status) const;
 643 #endif  /* U_HIDE_DEPRECATED_API */
 644
 645 #ifndef U_HIDE_INTERNAL_API
 646     /**
 647      * Internal function, do not use.
 648      * TODO:  figure out how to make this be non-public.
 649      *        NumberFormat::format(Formattable, ...
 650      *        needs to get at the DigitList, if it exists, for
 651      *        big decimal formatting.
 652      *  @internal
 653      */
 654     DigitList *getDigitList() const { return fDecimalNum;}
 655
 656     /**
 657      *  @internal
 658      */
 659     DigitList *getInternalDigitList();
 660
 661     /**
 662      *  Adopt, and set value from, a DigitList
 663      *     Internal Function, do not use.
 664      *  @param dl the Digit List to be adopted
 665      *  @internal
 666      */
 667     void adoptDigitList(DigitList *dl);
 668
 669     /**
 670      * Internal function to return the CharString pointer.
 671      * @param status error code
 672      * @return pointer to the CharString - may become invalid if the object is modified
 673      * @internal
 674      */
 675     CharString *internalGetCharString(UErrorCode &status);
 676
 677 #endif  /* U_HIDE_INTERNAL_API */
 678
 679 private:
 680     /**
 681      * Cleans up the memory for unwanted values.  For example, the adopted
 682      * string or array objects.
 683      */
 684     void            dispose(void);
 685
 686     /**
 687      * Common initialization, for use by constructors.
 688      */
 689     void            init();
 690
 691     UnicodeString* getBogus() const;
 692
 693     union {
 694         UObject*        fObject;
 695         UnicodeString*  fString;
 696         double          fDouble;
 697         int64_t         fInt64;
 698         UDate           fDate;
 699         struct {
 700           Formattable*  fArray;
 701           int32_t       fCount;
 702         }               fArrayAndCount;
 703     } fValue;
 704
 705     CharString           *fDecimalStr;
 706
 707     DigitList            *fDecimalNum;
 708
 709     char                fStackData[UNUM_INTERNAL_STACKARRAY_SIZE]; // must be big enough for DigitList
 710
 711     Type                fType;
 712     UnicodeString       fBogus; // Bogus string when it's needed.
 713 };
 714
 715 inline UDate Formattable::getDate(UErrorCode& status) const {
 716     if (fType != kDate) {
 717         if (U_SUCCESS(status)) {
 718             status = U_INVALID_FORMAT_ERROR;
 719         }
 720         return 0;
 721     }
 722     return fValue.fDate;
 723 }
 724
 725 inline const UnicodeString& Formattable::getString(void) const {
 726     return *fValue.fString;
 727 }
 728
 729 inline UnicodeString& Formattable::getString(void) {
 730     return *fValue.fString;
 731 }
 732
 733 #ifndef U_HIDE_DEPRECATED_API
 734 inline int32_t Formattable::getLong(UErrorCode* status) const {
 735     return getLong(*status);
 736 }
 737 #endif  /* U_HIDE_DEPRECATED_API */
 738
 739 inline UFormattable* Formattable::toUFormattable() {
 740   return reinterpret_cast<UFormattable*>(this);
 741 }
 742
 743 inline const UFormattable* Formattable::toUFormattable() const {
 744   return reinterpret_cast<const UFormattable*>(this);
 745 }
 746
 747 inline Formattable* Formattable::fromUFormattable(UFormattable *fmt) {
 748   return reinterpret_cast<Formattable *>(fmt);
 749 }
 750
 751 inline const Formattable* Formattable::fromUFormattable(const UFormattable *fmt) {
 752   return reinterpret_cast<const Formattable *>(fmt);
 753 }
 754
 755 U_NAMESPACE_END
 756
 757 #endif /* #if !UCONFIG_NO_FORMATTING */
 758
 759 #endif //_FMTABLE
 760 //eof