EIC code displayed by LXR master/​include/​unicode/​fmtable.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-04-24 08:57:01

 // © 2016 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 ********************************************************************************
 *   Copyright (C) 1997-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 ********************************************************************************
 *
 * File FMTABLE.H
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   02/29/97    aliu        Creation.
 ********************************************************************************
 */
 #ifndef FMTABLE_H
 #define FMTABLE_H
 
 #include "unicode/utypes.h"
 
 #if U_SHOW_CPLUSPLUS_API
 
 /**
  * \file
  * \brief C++ API: Formattable is a thin wrapper for primitive types used for formatting and parsing
  */
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "unicode/unistr.h"
 #include "unicode/stringpiece.h"
 #include "unicode/uformattable.h"
 
 U_NAMESPACE_BEGIN
 
 class CharString;
 
 namespace number::impl {
 class DecimalQuantity;
 }
 
 /**
  * Formattable objects can be passed to the Format class or
  * its subclasses for formatting.  Formattable is a thin wrapper
  * class which interconverts between the primitive numeric types
  * (double, long, etc.) as well as UDate and UnicodeString.
  *
  * <p>Internally, a Formattable object is a union of primitive types.
  * As such, it can only store one flavor of data at a time.  To
  * determine what flavor of data it contains, use the getType method.
  *
  * <p>As of ICU 3.0, Formattable may also wrap a UObject pointer,
  * which it owns.  This allows an instance of any ICU class to be
  * encapsulated in a Formattable.  For legacy reasons and for
  * efficiency, primitive numeric types are still stored directly
  * within a Formattable.
  *
  * <p>The Formattable class is not suitable for subclassing.
  *
  * <p>See UFormattable for a C wrapper.
  */
 class U_I18N_API Formattable : public UObject {
 public:
     /**
      * This enum is only used to let callers distinguish between
      * the Formattable(UDate) constructor and the Formattable(double)
      * constructor; the compiler cannot distinguish the signatures,
      * since UDate is currently typedefed to be either double or long.
      * If UDate is changed later to be a bonafide class
      * or struct, then we no longer need this enum.
      * @stable ICU 2.4
      */
     enum ISDATE { kIsDate };
 
     /**
      * Default constructor
      * @stable ICU 2.4
      */
     Formattable(); // Type kLong, value 0
 
     /**
      * Creates a Formattable object with a UDate instance.
      * @param d the UDate instance.
      * @param flag the flag to indicate this is a date. Always set it to kIsDate
      * @stable ICU 2.0
      */
     Formattable(UDate d, ISDATE flag);
 
     /**
      * Creates a Formattable object with a double number.
      * @param d the double number.
      * @stable ICU 2.0
      */
     Formattable(double d);
 
     /**
      * Creates a Formattable object with a long number.
      * @param l the long number.
      * @stable ICU 2.0
      */
     Formattable(int32_t l);
 
     /**
      * Creates a Formattable object with an int64_t number
      * @param ll the int64_t number.
      * @stable ICU 2.8
      */
     Formattable(int64_t ll);
 
 #if !UCONFIG_NO_CONVERSION
     /**
      * Creates a Formattable object with a char string pointer.
      * Assumes that the char string is null terminated.
      * @param strToCopy the char string.
      * @stable ICU 2.0
      */
     Formattable(const char* strToCopy);
 #endif
 
     /**
      * Creates a Formattable object of an appropriate numeric type from a
      * a decimal number in string form.  The Formattable will retain the
      * full precision of the input in decimal format, even when it exceeds
      * what can be represented by a double or int64_t.
      *
      * @param number  the unformatted (not localized) string representation
      *                     of the Decimal number.
      * @param status  the error code.  Possible errors include U_INVALID_FORMAT_ERROR
      *                if the format of the string does not conform to that of a
      *                decimal number.
      * @stable ICU 4.4
      */
     Formattable(StringPiece number, UErrorCode &status);
 
     /**
      * Creates a Formattable object with a UnicodeString object to copy from.
      * @param strToCopy the UnicodeString string.
      * @stable ICU 2.0
      */
     Formattable(const UnicodeString& strToCopy);
 
     /**
      * Creates a Formattable object with a UnicodeString object to adopt from.
      * @param strToAdopt the UnicodeString string.
      * @stable ICU 2.0
      */
     Formattable(UnicodeString* strToAdopt);
 
     /**
      * Creates a Formattable object with an array of Formattable objects.
      * @param arrayToCopy the Formattable object array.
      * @param count the array count.
      * @stable ICU 2.0
      */
     Formattable(const Formattable* arrayToCopy, int32_t count);
 
     /**
      * Creates a Formattable object that adopts the given UObject.
      * @param objectToAdopt the UObject to set this object to
      * @stable ICU 3.0
      */
     Formattable(UObject* objectToAdopt);
 
     /**
      * Copy constructor.
      * @stable ICU 2.0
      */
     Formattable(const Formattable&);
 
     /**
      * Assignment operator.
      * @param rhs   The Formattable object to copy into this object.
      * @stable ICU 2.0
      */
     Formattable&    operator=(const Formattable &rhs);
 
     /**
      * Equality comparison.
      * @param other    the object to be compared with.
      * @return        true if other are equal to this, false otherwise.
      * @stable ICU 2.0
      */
     bool           operator==(const Formattable &other) const;
 
     /**
      * Equality operator.
      * @param other    the object to be compared with.
      * @return        true if other are unequal to this, false otherwise.
      * @stable ICU 2.0
      */
     bool           operator!=(const Formattable& other) const
       { return !operator==(other); }
 
     /**
      * Destructor.
      * @stable ICU 2.0
      */
     virtual         ~Formattable();
 
     /**
      * Clone this object.
      * Clones can be used concurrently in multiple threads.
      * If an error occurs, then nullptr is returned.
      * The caller must delete the clone.
      *
      * @return a clone of this object
      *
      * @see getDynamicClassID
      * @stable ICU 2.8
      */
     Formattable *clone() const;
 
     /**
      * Selector for flavor of data type contained within a
      * Formattable object.  Formattable is a union of several
      * different types, and at any time contains exactly one type.
      * @stable ICU 2.4
      */
     enum Type {
         /**
          * Selector indicating a UDate value.  Use getDate to retrieve
          * the value.
          * @stable ICU 2.4
          */
         kDate,
 
         /**
          * Selector indicating a double value.  Use getDouble to
          * retrieve the value.
          * @stable ICU 2.4
          */
         kDouble,
 
         /**
          * Selector indicating a 32-bit integer value.  Use getLong to
          * retrieve the value.
          * @stable ICU 2.4
          */
         kLong,
 
         /**
          * Selector indicating a UnicodeString value.  Use getString
          * to retrieve the value.
          * @stable ICU 2.4
          */
         kString,
 
         /**
          * Selector indicating an array of Formattables.  Use getArray
          * to retrieve the value.
          * @stable ICU 2.4
          */
         kArray,
 
         /**
          * Selector indicating a 64-bit integer value.  Use getInt64
          * to retrieve the value.
          * @stable ICU 2.8
          */
         kInt64,
 
         /**
          * Selector indicating a UObject value.  Use getObject to
          * retrieve the value.
          * @stable ICU 3.0
          */
         kObject
    };
 
     /**
      * Gets the data type of this Formattable object.
      * @return    the data type of this Formattable object.
      * @stable ICU 2.0
      */
     Type getType() const;
 
     /**
      * Returns true if the data type of this Formattable object
      * is kDouble, kLong, or kInt64
      * @return true if this is a pure numeric object
      * @stable ICU 3.0
      */
     UBool           isNumeric() const;
 
     /**
      * Gets the double value of this object. If this object is not of type
      * kDouble then the result is undefined.
      * @return    the double value of this object.
      * @stable ICU 2.0
      */
     double getDouble() const { return fValue.fDouble; }
 
     /**
      * Gets the double value of this object. If this object is of type
      * long, int64 or Decimal Number then a conversion is performed, with
      * possible loss of precision.  If the type is kObject and the
      * object is a Measure, then the result of
      * getNumber().getDouble(status) is returned.  If this object is
      * neither a numeric type nor a Measure, then 0 is returned and
      * the status is set to U_INVALID_FORMAT_ERROR.
      * @param status the error code
      * @return the double value of this object.
      * @stable ICU 3.0
      */
     double          getDouble(UErrorCode& status) const;
 
     /**
      * Gets the long value of this object. If this object is not of type
      * kLong then the result is undefined.
      * @return    the long value of this object.
      * @stable ICU 2.0
      */
     int32_t getLong() const { return static_cast<int32_t>(fValue.fInt64); }
 
     /**
      * Gets the long value of this object. If the magnitude is too
      * large to fit in a long, then the maximum or minimum long value,
      * as appropriate, is returned and the status is set to
      * U_INVALID_FORMAT_ERROR.  If this object is of type kInt64 and
      * it fits within a long, then no precision is lost.  If it is of
      * type kDouble, then a conversion is performed, with
      * truncation of any fractional part.  If the type is kObject and
      * the object is a Measure, then the result of
      * getNumber().getLong(status) is returned.  If this object is
      * neither a numeric type nor a Measure, then 0 is returned and
      * the status is set to U_INVALID_FORMAT_ERROR.
      * @param status the error code
      * @return    the long value of this object.
      * @stable ICU 3.0
      */
     int32_t         getLong(UErrorCode& status) const;
 
     /**
      * Gets the int64 value of this object. If this object is not of type
      * kInt64 then the result is undefined.
      * @return    the int64 value of this object.
      * @stable ICU 2.8
      */
     int64_t getInt64() const { return fValue.fInt64; }
 
     /**
      * Gets the int64 value of this object. If this object is of a numeric
      * type and the magnitude is too large to fit in an int64, then
      * the maximum or minimum int64 value, as appropriate, is returned
      * and the status is set to U_INVALID_FORMAT_ERROR.  If the
      * magnitude fits in an int64, then a casting conversion is
      * performed, with truncation of any fractional part.  If the type
      * is kObject and the object is a Measure, then the result of
      * getNumber().getDouble(status) is returned.  If this object is
      * neither a numeric type nor a Measure, then 0 is returned and
      * the status is set to U_INVALID_FORMAT_ERROR.
      * @param status the error code
      * @return    the int64 value of this object.
      * @stable ICU 3.0
      */
     int64_t         getInt64(UErrorCode& status) const;
 
     /**
      * Gets the Date value of this object. If this object is not of type
      * kDate then the result is undefined.
      * @return    the Date value of this object.
      * @stable ICU 2.0
      */
     UDate           getDate() const { return fValue.fDate; }
 
     /**
      * Gets the Date value of this object.  If the type is not a date,
      * status is set to U_INVALID_FORMAT_ERROR and the return value is
      * undefined.
      * @param status the error code.
      * @return    the Date value of this object.
      * @stable ICU 3.0
      */
      UDate          getDate(UErrorCode& status) const;
 
     /**
      * Gets the string value of this object. If this object is not of type
      * kString then the result is undefined.
      * @param result    Output param to receive the Date value of this object.
      * @return          A reference to 'result'.
      * @stable ICU 2.0
      */
     UnicodeString&  getString(UnicodeString& result) const
       { result=*fValue.fString; return result; }
 
     /**
      * Gets the string value of this object. If the type is not a
      * string, status is set to U_INVALID_FORMAT_ERROR and a bogus
      * string is returned.
      * @param result    Output param to receive the Date value of this object.
      * @param status    the error code.
      * @return          A reference to 'result'.
      * @stable ICU 3.0
      */
     UnicodeString&  getString(UnicodeString& result, UErrorCode& status) const;
 
     /**
      * Gets a const reference to the string value of this object. If
      * this object is not of type kString then the result is
      * undefined.
      * @return   a const reference to the string value of this object.
      * @stable ICU 2.0
      */
     inline const UnicodeString& getString() const;
 
     /**
      * Gets a const reference to the string value of this object.  If
      * the type is not a string, status is set to
      * U_INVALID_FORMAT_ERROR and the result is a bogus string.
      * @param status    the error code.
      * @return   a const reference to the string value of this object.
      * @stable ICU 3.0
      */
     const UnicodeString& getString(UErrorCode& status) const;
 
     /**
      * Gets a reference to the string value of this object. If this
      * object is not of type kString then the result is undefined.
      * @return   a reference to the string value of this object.
      * @stable ICU 2.0
      */
     inline UnicodeString& getString();
 
     /**
      * Gets a reference to the string value of this object. If the
      * type is not a string, status is set to U_INVALID_FORMAT_ERROR
      * and the result is a bogus string.
      * @param status    the error code.
      * @return   a reference to the string value of this object.
      * @stable ICU 3.0
      */
     UnicodeString& getString(UErrorCode& status);
 
     /**
      * Gets the array value and count of this object. If this object
      * is not of type kArray then the result is undefined.
      * @param count    fill-in with the count of this object.
      * @return         the array value of this object.
      * @stable ICU 2.0
      */
     const Formattable* getArray(int32_t& count) const
       { count=fValue.fArrayAndCount.fCount; return fValue.fArrayAndCount.fArray; }
 
     /**
      * Gets the array value and count of this object. If the type is
      * not an array, status is set to U_INVALID_FORMAT_ERROR, count is
      * set to 0, and the result is nullptr.
      * @param count    fill-in with the count of this object.
      * @param status the error code.
      * @return         the array value of this object.
      * @stable ICU 3.0
      */
     const Formattable* getArray(int32_t& count, UErrorCode& status) const;
 
     /**
      * Accesses the specified element in the array value of this
      * Formattable object. If this object is not of type kArray then
      * the result is undefined.
      * @param index the specified index.
      * @return the accessed element in the array.
      * @stable ICU 2.0
      */
     Formattable&    operator[](int32_t index) { return fValue.fArrayAndCount.fArray[index]; }
 
     /**
      * Returns a pointer to the UObject contained within this
      * formattable, or nullptr if this object does not contain a UObject.
      * @return a UObject pointer, or nullptr
      * @stable ICU 3.0
      */
     const UObject*  getObject() const;
 
     /**
      * Returns a numeric string representation of the number contained within this
      * formattable, or nullptr if this object does not contain numeric type.
      * For values obtained by parsing, the returned decimal number retains
      * the full precision and range of the original input, unconstrained by
      * the limits of a double floating point or a 64 bit int.
      *
      * This function is not thread safe, and therefore is not declared const,
      * even though it is logically const.
      *
      * Possible errors include U_MEMORY_ALLOCATION_ERROR, and
      * U_INVALID_STATE if the formattable object has not been set to
      * a numeric type.
      *
      * @param status the error code.
      * @return the unformatted string representation of a number.
      * @stable ICU 4.4
      */
     StringPiece getDecimalNumber(UErrorCode &status);
 
      /**
      * Sets the double value of this object and changes the type to
      * kDouble.
      * @param d    the new double value to be set.
      * @stable ICU 2.0
      */
     void            setDouble(double d);
 
     /**
      * Sets the long value of this object and changes the type to
      * kLong.
      * @param l    the new long value to be set.
      * @stable ICU 2.0
      */
     void            setLong(int32_t l);
 
     /**
      * Sets the int64 value of this object and changes the type to
      * kInt64.
      * @param ll    the new int64 value to be set.
      * @stable ICU 2.8
      */
     void            setInt64(int64_t ll);
 
     /**
      * Sets the Date value of this object and changes the type to
      * kDate.
      * @param d    the new Date value to be set.
      * @stable ICU 2.0
      */
     void            setDate(UDate d);
 
     /**
      * Sets the string value of this object and changes the type to
      * kString.
      * @param stringToCopy    the new string value to be set.
      * @stable ICU 2.0
      */
     void            setString(const UnicodeString& stringToCopy);
 
     /**
      * Sets the array value and count of this object and changes the
      * type to kArray.
      * @param array    the array value.
      * @param count    the number of array elements to be copied.
      * @stable ICU 2.0
      */
     void            setArray(const Formattable* array, int32_t count);
 
     /**
      * Sets and adopts the string value and count of this object and
      * changes the type to kArray.
      * @param stringToAdopt    the new string value to be adopted.
      * @stable ICU 2.0
      */
     void            adoptString(UnicodeString* stringToAdopt);
 
     /**
      * Sets and adopts the array value and count of this object and
      * changes the type to kArray.
      * @stable ICU 2.0
      */
     void            adoptArray(Formattable* array, int32_t count);
 
     /**
      * Sets and adopts the UObject value of this object and changes
      * the type to kObject.  After this call, the caller must not
      * delete the given object.
      * @param objectToAdopt the UObject value to be adopted
      * @stable ICU 3.0
      */
     void            adoptObject(UObject* objectToAdopt);
 
     /**
      * Sets the the numeric value from a decimal number string, and changes
      * the type to to a numeric type appropriate for the number.
      * The syntax of the number is a "numeric string"
      * as defined in the Decimal Arithmetic Specification, available at
      * http://speleotrove.com/decimal
      * The full precision and range of the input number will be retained,
      * even when it exceeds what can be represented by a double or an int64.
      *
      * @param numberString  a string representation of the unformatted decimal number.
      * @param status        the error code.  Set to U_INVALID_FORMAT_ERROR if the
      *                      incoming string is not a valid decimal number.
      * @stable ICU 4.4
      */
     void             setDecimalNumber(StringPiece numberString,
                                       UErrorCode &status);
 
     /**
      * ICU "poor man's RTTI", returns a UClassID for the actual class.
      *
      * @stable ICU 2.2
      */
     virtual UClassID getDynamicClassID() const override;
 
     /**
      * ICU "poor man's RTTI", returns a UClassID for this class.
      *
      * @stable ICU 2.2
      */
     static UClassID U_EXPORT2 getStaticClassID();
 
     /**
      * Convert the UFormattable to a Formattable.  Internally, this is a reinterpret_cast.
      * @param fmt a valid UFormattable
      * @return the UFormattable as a Formattable object pointer.  This is an alias to the original
      * UFormattable, and so is only valid while the original argument remains in scope.
      * @stable ICU 52
      */
     static inline Formattable *fromUFormattable(UFormattable *fmt);
 
     /**
      * Convert the const UFormattable to a const Formattable.  Internally, this is a reinterpret_cast.
      * @param fmt a valid UFormattable
      * @return the UFormattable as a Formattable object pointer.  This is an alias to the original
      * UFormattable, and so is only valid while the original argument remains in scope.
      * @stable ICU 52
      */
     static inline const Formattable *fromUFormattable(const UFormattable *fmt);
 
     /**
      * Convert this object pointer to a UFormattable.
      * @return this object as a UFormattable pointer.   This is an alias to this object,
      * and so is only valid while this object remains in scope.
      * @stable ICU 52
      */
     inline UFormattable *toUFormattable();
 
     /**
      * Convert this object pointer to a UFormattable.
      * @return this object as a UFormattable pointer.   This is an alias to this object,
      * and so is only valid while this object remains in scope.
      * @stable ICU 52
      */
     inline const UFormattable *toUFormattable() const;
 
 #ifndef U_HIDE_DEPRECATED_API
     /**
      * Deprecated variant of getLong(UErrorCode&).
      * @param status the error code
      * @return the long value of this object.
      * @deprecated ICU 3.0 use getLong(UErrorCode&) instead
      */
     inline int32_t getLong(UErrorCode* status) const;
 #endif  /* U_HIDE_DEPRECATED_API */
 
 #ifndef U_HIDE_INTERNAL_API
     /**
      * Internal function, do not use.
      * TODO:  figure out how to make this be non-public.
      *        NumberFormat::format(Formattable, ...
      *        needs to get at the DecimalQuantity, if it exists, for
      *        big decimal formatting.
      *  @internal
      */
     number::impl::DecimalQuantity *getDecimalQuantity() const { return fDecimalQuantity;}
 
     /**
      * Export the value of this Formattable to a DecimalQuantity.
      * @internal
      */
     void populateDecimalQuantity(number::impl::DecimalQuantity& output, UErrorCode& status) const;
 
     /**
      *  Adopt, and set value from, a DecimalQuantity
      *     Internal Function, do not use.
      *  @param dq the DecimalQuantity to be adopted
      *  @internal
      */
     void adoptDecimalQuantity(number::impl::DecimalQuantity *dq);
 
     /**
      * Internal function to return the CharString pointer.
      * @param status error code
      * @return pointer to the CharString - may become invalid if the object is modified
      * @internal
      */
     CharString *internalGetCharString(UErrorCode &status);
 
 #endif  /* U_HIDE_INTERNAL_API */
 
 private:
     /**
      * Cleans up the memory for unwanted values.  For example, the adopted
      * string or array objects.
      */
     void dispose();
 
     /**
      * Common initialization, for use by constructors.
      */
     void            init();
 
     UnicodeString* getBogus() const;
 
     union {
         UObject*        fObject;
         UnicodeString*  fString;
         double          fDouble;
         int64_t         fInt64;
         UDate           fDate;
         struct {
           Formattable*  fArray;
           int32_t       fCount;
         }               fArrayAndCount;
     } fValue;
 
     CharString           *fDecimalStr;
 
     number::impl::DecimalQuantity *fDecimalQuantity;
 
     Type                fType;
     UnicodeString       fBogus; // Bogus string when it's needed.
 };
 
 inline UDate Formattable::getDate(UErrorCode& status) const {
     if (fType != kDate) {
         if (U_SUCCESS(status)) {
             status = U_INVALID_FORMAT_ERROR;
         }
         return 0;
     }
     return fValue.fDate;
 }
 
 inline const UnicodeString& Formattable::getString() const {
     return *fValue.fString;
 }
 
 inline UnicodeString& Formattable::getString() {
     return *fValue.fString;
 }
 
 #ifndef U_HIDE_DEPRECATED_API
 inline int32_t Formattable::getLong(UErrorCode* status) const {
     return getLong(*status);
 }
 #endif  /* U_HIDE_DEPRECATED_API */
 
 inline UFormattable* Formattable::toUFormattable() {
   return reinterpret_cast<UFormattable*>(this);
 }
 
 inline const UFormattable* Formattable::toUFormattable() const {
   return reinterpret_cast<const UFormattable*>(this);
 }
 
 inline Formattable* Formattable::fromUFormattable(UFormattable *fmt) {
   return reinterpret_cast<Formattable *>(fmt);
 }
 
 inline const Formattable* Formattable::fromUFormattable(const UFormattable *fmt) {
   return reinterpret_cast<const Formattable *>(fmt);
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 #endif /* U_SHOW_CPLUSPLUS_API */
 
 #endif //_FMTABLE
 //eof

This page was automatically generated by the 2.3.7 LXR engine. The LXR team