PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - usr/include/unicode - fmtable.h (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 2 6 33.3 %
Date: 2014-04-18 Functions: 2 5 40.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             : ********************************************************************************
       3             : *   Copyright (C) 1997-2006, 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             : #include "unicode/unistr.h"
      20             : /**
      21             :  * \file 
      22             :  * \brief C++ API: Formattable is a thin wrapper for primitive numeric types.
      23             :  */
      24             : 
      25             : #if !UCONFIG_NO_FORMATTING
      26             : 
      27             : U_NAMESPACE_BEGIN
      28             : 
      29             : /**
      30             :  * Formattable objects can be passed to the Format class or
      31             :  * its subclasses for formatting.  Formattable is a thin wrapper
      32             :  * class which interconverts between the primitive numeric types
      33             :  * (double, long, etc.) as well as UDate and UnicodeString.
      34             :  *
      35             :  * <p>Internally, a Formattable object is a union of primitive types.
      36             :  * As such, it can only store one flavor of data at a time.  To
      37             :  * determine what flavor of data it contains, use the getType method.
      38             :  *
      39             :  * <p>As of ICU 3.0, Formattable may also wrap a UObject pointer,
      40             :  * which it owns.  This allows an instance of any ICU class to be
      41             :  * encapsulated in a Formattable.  For legacy reasons and for
      42             :  * efficiency, primitive numeric types are still stored directly
      43             :  * within a Formattable.
      44             :  *
      45             :  * <p>The Formattable class is not suitable for subclassing.
      46             :  */
      47             : class U_I18N_API Formattable : public UObject {
      48             : public:
      49             :     /**
      50             :      * This enum is only used to let callers distinguish between
      51             :      * the Formattable(UDate) constructor and the Formattable(double)
      52             :      * constructor; the compiler cannot distinguish the signatures,
      53             :      * since UDate is currently typedefed to be either double or long.
      54             :      * If UDate is changed later to be a bonafide class
      55             :      * or struct, then we no longer need this enum.
      56             :      * @stable ICU 2.4
      57             :      */
      58             :     enum ISDATE { kIsDate };
      59             : 
      60             :     /**
      61             :      * Default constructor
      62             :      * @stable ICU 2.4
      63             :      */
      64             :     Formattable(); // Type kLong, value 0
      65             : 
      66             :     /**
      67             :      * Creates a Formattable object with a UDate instance.
      68             :      * @param d the UDate instance.
      69             :      * @param flag the flag to indicate this is a date. Always set it to kIsDate
      70             :      * @stable ICU 2.0  
      71             :      */
      72             :     Formattable(UDate d, ISDATE flag);
      73             : 
      74             :     /**
      75             :      * Creates a Formattable object with a double number.
      76             :      * @param d the double number.
      77             :      * @stable ICU 2.0
      78             :      */
      79             :     Formattable(double d);
      80             : 
      81             :     /**
      82             :      * Creates a Formattable object with a long number.
      83             :      * @param l the long number.
      84             :      * @stable ICU 2.0
      85             :      */
      86             :     Formattable(int32_t l);
      87             : 
      88             :     /**
      89             :      * Creates a Formattable object with an int64_t number
      90             :      * @param ll the int64_t number.
      91             :      * @stable ICU 2.8
      92             :      */
      93             :     Formattable(int64_t ll);
      94             : 
      95             : #if !UCONFIG_NO_CONVERSION
      96             :     /**
      97             :      * Creates a Formattable object with a char string pointer.
      98             :      * Assumes that the char string is null terminated.
      99             :      * @param strToCopy the char string.
     100             :      * @stable ICU 2.0
     101             :      */
     102             :     Formattable(const char* strToCopy);
     103             : #endif
     104             : 
     105             :     /**
     106             :      * Creates a Formattable object with a UnicodeString object to copy from.
     107             :      * @param strToCopy the UnicodeString string.
     108             :      * @stable ICU 2.0
     109             :      */
     110             :     Formattable(const UnicodeString& strToCopy);
     111             : 
     112             :     /**
     113             :      * Creates a Formattable object with a UnicodeString object to adopt from.
     114             :      * @param strToAdopt the UnicodeString string.
     115             :      * @stable ICU 2.0
     116             :      */
     117             :     Formattable(UnicodeString* strToAdopt);
     118             : 
     119             :     /**
     120             :      * Creates a Formattable object with an array of Formattable objects.
     121             :      * @param arrayToCopy the Formattable object array.
     122             :      * @param count the array count.
     123             :      * @stable ICU 2.0
     124             :      */
     125             :     Formattable(const Formattable* arrayToCopy, int32_t count);
     126             : 
     127             :     /**
     128             :      * Creates a Formattable object that adopts the given UObject.
     129             :      * @param objectToAdopt the UObject to set this object to
     130             :      * @stable ICU 3.0
     131             :      */
     132             :     Formattable(UObject* objectToAdopt);
     133             : 
     134             :     /**
     135             :      * Copy constructor.
     136             :      * @stable ICU 2.0
     137             :      */
     138             :     Formattable(const Formattable&);
     139             : 
     140             :     /**
     141             :      * Assignment operator.
     142             :      * @param rhs   The Formattable object to copy into this object.
     143             :      * @stable ICU 2.0
     144             :      */
     145             :     Formattable&    operator=(const Formattable &rhs);
     146             : 
     147             :     /**
     148             :      * Equality comparison.
     149             :      * @param other    the object to be compared with.
     150             :      * @return        TRUE if other are equal to this, FALSE otherwise.
     151             :      * @stable ICU 2.0
     152             :      */
     153             :     UBool          operator==(const Formattable &other) const;
     154             :     
     155             :     /** 
     156             :      * Equality operator.
     157             :      * @param other    the object to be compared with.
     158             :      * @return        TRUE if other are unequal to this, FALSE otherwise.
     159             :      * @stable ICU 2.0
     160             :      */
     161             :     UBool          operator!=(const Formattable& other) const
     162             :       { return !operator==(other); }
     163             : 
     164             :     /** 
     165             :      * Destructor.
     166             :      * @stable ICU 2.0
     167             :      */
     168             :     virtual         ~Formattable();
     169             : 
     170             :     /**
     171             :      * Clone this object.
     172             :      * Clones can be used concurrently in multiple threads.
     173             :      * If an error occurs, then NULL is returned.
     174             :      * The caller must delete the clone.
     175             :      *
     176             :      * @return a clone of this object
     177             :      *
     178             :      * @see getDynamicClassID
     179             :      * @stable ICU 2.8
     180             :      */
     181             :     Formattable *clone() const;
     182             : 
     183             :     /** 
     184             :      * Selector for flavor of data type contained within a
     185             :      * Formattable object.  Formattable is a union of several
     186             :      * different types, and at any time contains exactly one type.
     187             :      * @stable ICU 2.4
     188             :      */
     189             :     enum Type {
     190             :         /**
     191             :          * Selector indicating a UDate value.  Use getDate to retrieve
     192             :          * the value.
     193             :          * @stable ICU 2.4
     194             :          */
     195             :         kDate,
     196             : 
     197             :         /**
     198             :          * Selector indicating a double value.  Use getDouble to
     199             :          * retrieve the value.
     200             :          * @stable ICU 2.4
     201             :          */
     202             :         kDouble,
     203             : 
     204             :         /**
     205             :          * Selector indicating a 32-bit integer value.  Use getLong to
     206             :          * retrieve the value.
     207             :          * @stable ICU 2.4
     208             :          */
     209             :         kLong,
     210             : 
     211             :         /**
     212             :          * Selector indicating a UnicodeString value.  Use getString
     213             :          * to retrieve the value.
     214             :          * @stable ICU 2.4
     215             :          */
     216             :         kString,
     217             : 
     218             :         /**
     219             :          * Selector indicating an array of Formattables.  Use getArray
     220             :          * to retrieve the value.
     221             :          * @stable ICU 2.4
     222             :          */
     223             :         kArray,
     224             : 
     225             :         /**
     226             :          * Selector indicating a 64-bit integer value.  Use getInt64
     227             :          * to retrieve the value.
     228             :          * @stable ICU 2.8
     229             :          */
     230             :         kInt64,
     231             : 
     232             :         /**
     233             :          * Selector indicating a UObject value.  Use getObject to
     234             :          * retrieve the value.
     235             :          * @stable ICU 3.0
     236             :          */
     237             :         kObject
     238             :    };
     239             : 
     240             :     /**
     241             :      * Gets the data type of this Formattable object.
     242             :      * @return    the data type of this Formattable object.
     243             :      * @stable ICU 2.0
     244             :      */
     245             :     Type            getType(void) const;
     246             :     
     247             :     /**
     248             :      * Returns TRUE if the data type of this Formattable object
     249             :      * is kDouble, kLong, or kInt64.
     250             :      * @return TRUE if this is a pure numeric object
     251             :      * @stable ICU 3.0
     252             :      */
     253             :     UBool           isNumeric() const;
     254             :     
     255             :     /**
     256             :      * Gets the double value of this object. If this object is not of type
     257             :      * kDouble then the result is undefined.
     258             :      * @return    the double value of this object.
     259             :      * @stable ICU 2.0
     260             :      */ 
     261          16 :     double          getDouble(void) const { return fValue.fDouble; }
     262             : 
     263             :     /**
     264             :      * Gets the double value of this object. If this object is of type
     265             :      * long or int64 then a casting conversion is peformed, with
     266             :      * possible loss of precision.  If the type is kObject and the
     267             :      * object is a Measure, then the result of
     268             :      * getNumber().getDouble(status) is returned.  If this object is
     269             :      * neither a numeric type nor a Measure, then 0 is returned and
     270             :      * the status is set to U_INVALID_FORMAT_ERROR.
     271             :      * @param status the error code
     272             :      * @return the double value of this object.
     273             :      * @stable ICU 3.0
     274             :      */ 
     275             :     double          getDouble(UErrorCode& status) const;
     276             : 
     277             :     /**
     278             :      * Gets the long value of this object. If this object is not of type
     279             :      * kLong then the result is undefined.
     280             :      * @return    the long value of this object.
     281             :      * @stable ICU 2.0
     282             :      */ 
     283          36 :     int32_t         getLong(void) const { return (int32_t)fValue.fInt64; }
     284             : 
     285             :     /**
     286             :      * Gets the long value of this object. If the magnitude is too
     287             :      * large to fit in a long, then the maximum or minimum long value,
     288             :      * as appropriate, is returned and the status is set to
     289             :      * U_INVALID_FORMAT_ERROR.  If this object is of type kInt64 and
     290             :      * it fits within a long, then no precision is lost.  If it is of
     291             :      * type kDouble, then a casting conversion is peformed, with
     292             :      * truncation of any fractional part.  If the type is kObject and
     293             :      * the object is a Measure, then the result of
     294             :      * getNumber().getLong(status) is returned.  If this object is
     295             :      * neither a numeric type nor a Measure, then 0 is returned and
     296             :      * the status is set to U_INVALID_FORMAT_ERROR.
     297             :      * @param status the error code
     298             :      * @return    the long value of this object.
     299             :      * @stable ICU 3.0
     300             :      */ 
     301             :     int32_t         getLong(UErrorCode& status) const;
     302             : 
     303             :     /**
     304             :      * Gets the int64 value of this object. If this object is not of type
     305             :      * kInt64 then the result is undefined.
     306             :      * @return    the int64 value of this object.
     307             :      * @stable ICU 2.8
     308             :      */ 
     309           0 :     int64_t         getInt64(void) const { return fValue.fInt64; }
     310             : 
     311             :     /**
     312             :      * Gets the int64 value of this object. If this object is of type
     313             :      * kDouble and the magnitude is too large to fit in an int64, then
     314             :      * the maximum or minimum int64 value, as appropriate, is returned
     315             :      * and the status is set to U_INVALID_FORMAT_ERROR.  If the
     316             :      * magnitude fits in an int64, then a casting conversion is
     317             :      * peformed, with truncation of any fractional part.  If the type
     318             :      * is kObject and the object is a Measure, then the result of
     319             :      * getNumber().getDouble(status) is returned.  If this object is
     320             :      * neither a numeric type nor a Measure, then 0 is returned and
     321             :      * the status is set to U_INVALID_FORMAT_ERROR.
     322             :      * @param status the error code
     323             :      * @return    the int64 value of this object.
     324             :      * @stable ICU 3.0
     325             :      */ 
     326             :     int64_t         getInt64(UErrorCode& status) const;
     327             : 
     328             :     /**
     329             :      * Gets the Date value of this object. If this object is not of type
     330             :      * kDate then the result is undefined.
     331             :      * @return    the Date value of this object.
     332             :      * @stable ICU 2.0
     333             :      */ 
     334           0 :     UDate           getDate() const { return fValue.fDate; }
     335             : 
     336             :     /**
     337             :      * Gets the Date value of this object.  If the type is not a date,
     338             :      * status is set to U_INVALID_FORMAT_ERROR and the return value is
     339             :      * undefined.
     340             :      * @param status the error code.
     341             :      * @return    the Date value of this object.
     342             :      * @stable ICU 3.0
     343             :      */ 
     344             :      UDate          getDate(UErrorCode& status) const;
     345             : 
     346             :     /**
     347             :      * Gets the string value of this object. If this object is not of type
     348             :      * kString then the result is undefined.
     349             :      * @param result    Output param to receive the Date value of this object.
     350             :      * @return          A reference to 'result'.
     351             :      * @stable ICU 2.0
     352             :      */ 
     353           0 :     UnicodeString&  getString(UnicodeString& result) const
     354           0 :       { result=*fValue.fString; return result; }
     355             : 
     356             :     /**
     357             :      * Gets the string value of this object. If the type is not a
     358             :      * string, status is set to U_INVALID_FORMAT_ERROR and a bogus
     359             :      * string is returned.
     360             :      * @param result    Output param to receive the Date value of this object.
     361             :      * @param status    the error code. 
     362             :      * @return          A reference to 'result'.
     363             :      * @stable ICU 3.0
     364             :      */ 
     365             :     UnicodeString&  getString(UnicodeString& result, UErrorCode& status) const;
     366             : 
     367             :     /**
     368             :      * Gets a const reference to the string value of this object. If
     369             :      * this object is not of type kString then the result is
     370             :      * undefined.
     371             :      * @return   a const reference to the string value of this object.
     372             :      * @stable ICU 2.0
     373             :      */
     374             :     inline const UnicodeString& getString(void) const;
     375             : 
     376             :     /**
     377             :      * Gets a const reference to the string value of this object.  If
     378             :      * the type is not a string, status is set to
     379             :      * U_INVALID_FORMAT_ERROR and the result is a bogus string.
     380             :      * @param status    the error code.
     381             :      * @return   a const reference to the string value of this object.
     382             :      * @stable ICU 3.0
     383             :      */
     384             :     const UnicodeString& getString(UErrorCode& status) const;
     385             : 
     386             :     /**
     387             :      * Gets a reference to the string value of this object. If this
     388             :      * object is not of type kString then the result is undefined.
     389             :      * @return   a reference to the string value of this object.
     390             :      * @stable ICU 2.0
     391             :      */
     392             :     inline UnicodeString& getString(void);
     393             : 
     394             :     /**
     395             :      * Gets a reference to the string value of this object. If the
     396             :      * type is not a string, status is set to U_INVALID_FORMAT_ERROR
     397             :      * and the result is a bogus string.
     398             :      * @param status    the error code. 
     399             :      * @return   a reference to the string value of this object.
     400             :      * @stable ICU 3.0
     401             :      */
     402             :     UnicodeString& getString(UErrorCode& status);
     403             : 
     404             :     /**
     405             :      * Gets the array value and count of this object. If this object
     406             :      * is not of type kArray then the result is undefined.
     407             :      * @param count    fill-in with the count of this object.
     408             :      * @return         the array value of this object.
     409             :      * @stable ICU 2.0
     410             :      */ 
     411             :     const Formattable* getArray(int32_t& count) const
     412             :       { count=fValue.fArrayAndCount.fCount; return fValue.fArrayAndCount.fArray; }
     413             : 
     414             :     /**
     415             :      * Gets the array value and count of this object. If the type is
     416             :      * not an array, status is set to U_INVALID_FORMAT_ERROR, count is
     417             :      * set to 0, and the result is NULL.
     418             :      * @param count    fill-in with the count of this object.
     419             :      * @param status the error code. 
     420             :      * @return         the array value of this object.
     421             :      * @stable ICU 3.0
     422             :      */ 
     423             :     const Formattable* getArray(int32_t& count, UErrorCode& status) const;
     424             : 
     425             :     /**
     426             :      * Accesses the specified element in the array value of this
     427             :      * Formattable object. If this object is not of type kArray then
     428             :      * the result is undefined.
     429             :      * @param index the specified index.
     430             :      * @return the accessed element in the array.
     431             :      * @stable ICU 2.0
     432             :      */
     433             :     Formattable&    operator[](int32_t index) { return fValue.fArrayAndCount.fArray[index]; }
     434             :        
     435             :     /**
     436             :      * Returns a pointer to the UObject contained within this
     437             :      * formattable, or NULL if this object does not contain a UObject.
     438             :      * @return a UObject pointer, or NULL
     439             :      * @stable ICU 3.0
     440             :      */
     441             :     const UObject*  getObject() const;
     442             : 
     443             :     /**
     444             :      * Sets the double value of this object and changes the type to
     445             :      * kDouble.
     446             :      * @param d    the new double value to be set.
     447             :      * @stable ICU 2.0
     448             :      */ 
     449             :     void            setDouble(double d);
     450             : 
     451             :     /**
     452             :      * Sets the long value of this object and changes the type to
     453             :      * kLong.
     454             :      * @param l    the new long value to be set.
     455             :      * @stable ICU 2.0
     456             :      */ 
     457             :     void            setLong(int32_t l);
     458             : 
     459             :     /**
     460             :      * Sets the int64 value of this object and changes the type to
     461             :      * kInt64.
     462             :      * @param ll    the new int64 value to be set.
     463             :      * @stable ICU 2.8
     464             :      */ 
     465             :     void            setInt64(int64_t ll);
     466             : 
     467             :     /**
     468             :      * Sets the Date value of this object and changes the type to
     469             :      * kDate.
     470             :      * @param d    the new Date value to be set.
     471             :      * @stable ICU 2.0
     472             :      */ 
     473             :     void            setDate(UDate d);
     474             : 
     475             :     /**
     476             :      * Sets the string value of this object and changes the type to
     477             :      * kString.
     478             :      * @param stringToCopy    the new string value to be set.
     479             :      * @stable ICU 2.0
     480             :      */ 
     481             :     void            setString(const UnicodeString& stringToCopy);
     482             : 
     483             :     /**
     484             :      * Sets the array value and count of this object and changes the
     485             :      * type to kArray.
     486             :      * @param array    the array value.
     487             :      * @param count    the number of array elements to be copied.
     488             :      * @stable ICU 2.0
     489             :      */ 
     490             :     void            setArray(const Formattable* array, int32_t count);
     491             : 
     492             :     /**
     493             :      * Sets and adopts the string value and count of this object and
     494             :      * changes the type to kArray.
     495             :      * @param stringToAdopt    the new string value to be adopted.
     496             :      * @stable ICU 2.0
     497             :      */ 
     498             :     void            adoptString(UnicodeString* stringToAdopt);
     499             : 
     500             :     /**
     501             :      * Sets and adopts the array value and count of this object and
     502             :      * changes the type to kArray.
     503             :      * @stable ICU 2.0
     504             :      */ 
     505             :     void            adoptArray(Formattable* array, int32_t count);
     506             :        
     507             :     /**
     508             :      * Sets and adopts the UObject value of this object and changes
     509             :      * the type to kObject.  After this call, the caller must not
     510             :      * delete the given object.
     511             :      * @param objectToAdopt the UObject value to be adopted
     512             :      * @stable ICU 3.0
     513             :      */
     514             :     void            adoptObject(UObject* objectToAdopt);
     515             : 
     516             :     /**
     517             :      * ICU "poor man's RTTI", returns a UClassID for the actual class.
     518             :      *
     519             :      * @stable ICU 2.2
     520             :      */
     521             :     virtual UClassID getDynamicClassID() const;
     522             : 
     523             :     /**
     524             :      * ICU "poor man's RTTI", returns a UClassID for this class.
     525             :      *
     526             :      * @stable ICU 2.2
     527             :      */
     528             :     static UClassID U_EXPORT2 getStaticClassID();
     529             : 
     530             :     /**
     531             :      * Deprecated variant of getLong(UErrorCode&).
     532             :      * @param status the error code
     533             :      * @return the long value of this object.
     534             :      * @deprecated ICU 3.0 use getLong(UErrorCode&) instead
     535             :      */ 
     536             :     inline int32_t getLong(UErrorCode* status) const;
     537             : 
     538             : private:
     539             :     /**
     540             :      * Cleans up the memory for unwanted values.  For example, the adopted
     541             :      * string or array objects.
     542             :      */
     543             :     void            dispose(void);
     544             : 
     545             :     UnicodeString* getBogus() const;
     546             : 
     547             :     union {
     548             :         UObject*        fObject;
     549             :         UnicodeString*  fString;
     550             :         double          fDouble;
     551             :         int64_t         fInt64;
     552             :         UDate           fDate;
     553             :         struct {
     554             :           Formattable*  fArray;
     555             :           int32_t       fCount;
     556             :         }               fArrayAndCount;
     557             :     } fValue;
     558             : 
     559             :     Type                fType;
     560             :     UnicodeString       fBogus; // Bogus string when it's needed.
     561             : };
     562             : 
     563             : inline UDate Formattable::getDate(UErrorCode& status) const {
     564             :     if (fType != kDate) {
     565             :         if (U_SUCCESS(status)) {
     566             :             status = U_INVALID_FORMAT_ERROR;
     567             :         }
     568             :         return 0;
     569             :     }
     570             :     return fValue.fDate;
     571             : }
     572             : 
     573             : inline const UnicodeString& Formattable::getString(void) const {
     574             :     return *fValue.fString;
     575             : }
     576             : 
     577             : inline UnicodeString& Formattable::getString(void) {
     578             :     return *fValue.fString;
     579             : }
     580             : 
     581             : inline int32_t Formattable::getLong(UErrorCode* status) const {
     582             :     return getLong(*status);
     583             : }
     584             : 
     585             : U_NAMESPACE_END
     586             : 
     587             : #endif /* #if !UCONFIG_NO_FORMATTING */
     588             : 
     589             : #endif //_FMTABLE
     590             : //eof
     591             : 

Generated by: LCOV version 1.10

Generated at Fri, 18 Apr 2014 07:01:22 +0000 (6 days ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.