inc/FBaseFloat.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FBaseFloat.h
  20  * @brief               This is the header file for the %Float class.
  21  *
  22  * @see                 Tizen::Base::Number
  23  *
  24  * This header file contains the declarations of the %Float class.
  25  */
  26 #ifndef _FBASE_FLOAT_H_
  27 #define _FBASE_FLOAT_H_
  28
  29 #include <FBaseNumber.h>
  30
  31
  32 namespace Tizen { namespace Base
  33 {
  34 /**
  35  *      @class  Float
  36  *      @brief  This class is the wrapper class for the @c signed @c float built-in type.
  37  *
  38  *      @since  2.0
  39  *
  40  *      The %Float class represents a single-precision 32-bit floating number. The %Float class wraps a @c float type value. This enables
  41  *      passing a @c float value to a method that only accepts an instance of Object class. This class provides methods to compare instances
  42  *      of this type, convert the value of an instance to its string representation, and convert the string representation
  43  *      of a number to an instance of this type.
  44  *
  45  * The following example demonstrates how to use the %Float class.
  46  *
  47  *      @code
  48  *
  49  *      #include <FBase.h>
  50  *
  51  *      using namespace Tizen::Base;
  52  *
  53  *      // This method checks whether the given string object contains the string
  54  *      // representation of the pre-defined minimum float value.
  55  *      result
  56  *      MyClass::Verify(String& string, bool& out)
  57  *      {
  58  *              // Creates and initializes an instance of Double
  59  *              static const Float MINIMUM(1.23L);
  60  *
  61  *              result r = E_SUCCESS;
  62  *
  63  *              float f;
  64  *
  65  *              // Parses the string representation of the numeric value
  66  *              // Returns f (value as signed float)
  67  *              r = Float::Parse(string, f);
  68  *
  69  *              // Error Handling
  70  *              if (IsFailed(r))
  71  *              {
  72  *                      goto CATCH;
  73  *              }
  74  *
  75  *              out = (MINIMUM.CompareTo(f) == 0) ? true: false;
  76  *              return r;
  77  *      CATCH:
  78  *              return r;
  79  *      }
  80  *      @endcode
  81  */
  82 class _OSP_EXPORT_ Float
  83         : public Number
  84 {
  85 public:
  86         /**
  87          *      Initializes this instance of %Float with the specified value.
  88          *
  89          *      @since                  2.0
  90          *
  91          *      @param[in]      value   A @c float value
  92          */
  93         Float(float value = 0.0);
  94
  95
  96         /**
  97          *      Copying of objects using this copy constructor is allowed.
  98          *
  99          *      @since                  2.0
 100          *
 101          *      @param[in]      value   An instance of %Float
 102          */
 103         Float(const Float& value);
 104
 105         /**
 106          *      This destructor overrides Tizen::Base::Object::~Object().
 107          *
 108          *      @since  2.0
 109          */
 110         virtual ~Float(void);
 111
 112         /**
 113          *      Copying of objects using this copy assignment operator is allowed.
 114          *
 115          *      @since                  2.0
 116          *
 117          *      @param[in]      rhs     An instance of %Float
 118          */
 119         Float& operator =(const Float& rhs);
 120
 121         /**
 122          *      Compares two @c float values.
 123          *
 124          *      @since          2.0
 125          *
 126          *      @return         A 32-bit @c signed integer value
 127          *      @code
 128          *      <  0  if the value of @c f1 is less than the value of @c f2
 129          *      == 0  if the value of @c f1 is equal to the value of @c f2
 130          *      >  0  if the value of @c f1 is greater than the value of @c f2
 131          *      @endcode
 132          *      @param[in]      f1      The first @c float value to compare
 133          *      @param[in]      f2      The second @c float value to compare
 134          */
 135         static int Compare(float f1, float f2);
 136
 137         /**
 138          *      Compares the value of the current instance with the value of the specified instance of the %Float class.
 139          *
 140          *      @since          2.0
 141          *
 142          *      @return         A 32-bit @c signed integer value
 143          *      @code
 144          *      @li <  0    if the value of the current instance is less than the value of the specified instance
 145          *      @li == 0    if the value of the current instance is equal to the value of the specified instance
 146          *      @li >  0    if the value of the current instance is greater than the value of the specified instance
 147          *      @endcode
 148          *      @param[in]      value   An instance of the %Float class to compare
 149          */
 150         int CompareTo(const Float& value) const;
 151
 152         /**
 153          *      Checks whether the value of the specified instance of Object is equal to the value of the current instance of %Float.
 154          *
 155          *      @since          2.0
 156          *
 157          *      @return         @c true if the value of the specified instance of Object is equal to the value of the current instance of %Float, @n
 158          *                              else @c false
 159          *      @param[in]      obj             An instance of Object to compare
 160          *      @see            Tizen::Base::Object::Equals()
 161          */
 162         virtual bool Equals(const Object& obj) const;
 163
 164
 165         /**
 166          *      Gets the hash value of the current instance of %Float.
 167          *
 168          *      @since          2.0
 169          *
 170          *      @return         An integer value indicating the hash value of the current instance of %Float
 171          *      @remarks        Two equal instances must return the same hash value. For better performance,
 172          *                              the used hash function must generate a random distribution for all inputs. @n
 173          *                              The default implementation of this method returns the value of the current instance.
 174          */
 175         virtual int GetHashCode(void) const;
 176
 177         /**
 178         *        Gets the hash value of the specified @c float value.
 179         *
 180         *        @since         2.0
 181         *
 182         *        @return        An integer value indicating the hash value of the specified @c float value
 183         *        @param[in]   val   A @c float value to get the hash value
 184         */
 185         static int GetHashCode(float val);
 186
 187         /**
 188          * Parses the specified string representing a numeric value and returns the value as @c signed @c float (as out parameter).
 189          *
 190          *      @since                  2.0
 191          *
 192          *      @return                 An error code
 193          *      @param[in]      s                       A unicode string representing a @c signed @c float value
 194          *      @param[out]     ret                     The numeric representation of the string
 195          *      @exception      E_SUCCESS        The method is successful.
 196          *      @exception      E_NUM_FORMAT The specified string does not contain a number that can be parsed.
 197          *      @see            Tizen::Base::Double::Parse()
 198          */
 199         static result Parse(const String& s, float& ret);
 200
 201         /**
 202          *      Gets the @c signed @c char equivalent of the current instance of the %Float class.
 203          *
 204          *      @since          2.0
 205          *
 206          *      @return         A @c signed @c char equivalent of the current instance
 207          */
 208         virtual char ToChar(void) const;
 209
 210         /**
 211          *      Gets the @c signed @c short equivalent of the current instance of the %Float class.
 212          *
 213          *      @since          2.0
 214          *
 215          *      @return         A @c signed @c short equivalent of the current instance
 216          */
 217         virtual short ToShort(void) const;
 218
 219         /**
 220          *      Gets the @c signed @c int equivalent of the current instance of the %Float class.
 221          *
 222          *      @since          2.0
 223          *
 224          *      @return         A @c signed @c int equivalent of the current instance
 225          */
 226         virtual int ToInt(void) const;
 227
 228         /**
 229          *      Gets the @c signed @c long equivalent of the current instance of the %Float class.
 230          *
 231          *      @since          2.0
 232          *
 233          *      @return         A @c signed @c long equivalent of the current instance
 234          */
 235         virtual long ToLong(void) const;
 236
 237         /**
 238          * Gets the @c signed @c long @c long equivalent of the current instance of the %Float class.
 239          *
 240          * @since               2.0
 241          *
 242          * @return      A @c signed @c long @c long equivalent of the current instance
 243          */
 244         virtual long long ToLongLong(void) const;
 245
 246         /**
 247          *      Gets the @c signed @c float equivalent of the current instance of the %Float class.
 248          *
 249          *      @since          2.0
 250          *
 251          *      @return         A @c signed @c float equivalent of the current instance
 252          */
 253         virtual float ToFloat(void) const;
 254
 255         /**
 256          *      Gets the @c signed @c double equivalent of the current instance of the %Float class.
 257          *
 258          *      @since          2.0
 259          *
 260          *      @return         A @c signed @c double equivalent of the current instance
 261          */
 262         virtual double ToDouble(void) const;
 263
 264         /**
 265          * Gets the string representing the value of the current instance of %Float.
 266          *
 267          * @since                       2.0
 268          *
 269          * @return              A string containing a Unicode representation of the value of the current instance
 270          * @remarks             If the value is Not-a-Number (NaN), the result is the string "NaN". Furthermore, infinity
 271          *                              produces the result "Infinity". @n
 272          *                              6 digits are given for the precision of this method. Use String::Format() to set the specific precision.
 273          */
 274         virtual String ToString(void) const;
 275
 276         /**
 277          *      Gets the string representing the specified @c float value.
 278          *
 279          *      @since          2.0
 280          *
 281          *      @return         A string containing a Unicode representation of the specified @c float value
 282          *      @param[in]      value   A @c float value to convert
 283          *  @remarks    If the value is Not-a-Number (NaN), the result is the string "NaN". Furthermore, infinity
 284          *                              produces the result "Infinity". @n
 285          *                              6 digits are given for the precision of this method. Use String::Format() to set the specific precision.
 286          */
 287         static String ToString(float value);
 288
 289         /**
 290          *      Gets the IEEE 754 floating-point "single format" bit layout representation of the specified @c float value.
 291          *
 292          *      @since          2.0
 293          *
 294          *      @return         The bits that represent the floating-point number in the IEEE 754 floating-point "single format" bit layout
 295          *      @param[in]      value   A @c float value to convert
 296          *      @see            Tizen::Base::Double::Parse()
 297          */
 298         static int ToBits(float value);
 299
 300         /**
 301          *      Gets the @c float value corresponding to the specified floating-point value in the IEEE 754 floating-point "single format" bit layout.
 302          *
 303          *      @since          2.0
 304          *
 305          *      @return         The @c float floating-point value with the same bit pattern
 306          *      @param[in]      value   A floating-point value in the IEEE 754 floating-point "single format" bit layout
 307          *      @see            Tizen::Base::Double::Parse()
 308          */
 309         static float ToFloatFromBits(int value);
 310
 311         /**
 312          *      Checks whether the current value of %Float is equal to negative or positive infinity.
 313          *
 314          *      @since          2.0
 315          *
 316          *      @return         @c true if the current value equals negative or positive infinity, @n
 317          *                              else @c false
 318          */
 319         bool IsInfinity(void) const;
 320
 321         /**
 322          *      Checks whether the specified @c float value is equal to negative or positive infinity.
 323          *
 324          *      @since          2.0
 325          *
 326          *      @return         @c true if the specified value equals negative or positive infinity, @n
 327          *                              else @c false
 328          *      @param[in]      value   A @c float value to check
 329          */
 330         static bool IsInfinity(float value);
 331
 332         /**
 333          *      Checks whether the current value is Not-a-Number.
 334          *
 335          *      @since          2.0
 336          *
 337          *      @return         @c true if the current value is Not-a-Number, @n
 338          *                              else @c false
 339          */
 340         bool IsNaN(void) const;
 341
 342         /**
 343          *      Checks whether the specified value is Not-a-Number.
 344          *
 345          *      @since          2.0
 346          *
 347          *      @return         @c true if the specified value is Not-a-Number, @n
 348          *                              else @c false
 349          *      @param[in]      value   A @c float value to check
 350          */
 351         static bool IsNaN(float value);
 352
 353         /**
 354          *      Gets a constant holding the largest positive finite value of type @c float. @n
 355          *      This is equal to the value defined in Limit.h of the C library.
 356          *
 357          *      @since          2.0
 358          *
 359          *      @return         A constant holding the largest positive finite value of type @c float
 360          */
 361         static float GetMaxValue(void);
 362
 363         /**
 364          *      Gets a constant holding the smallest positive non-zero value of type @c float. @n
 365          *      This is equal to the value defined in Limit.h of the C library.
 366          *
 367          *      @since          2.0
 368          *
 369          *      @return         A constant holding the smallest possible non-zero value of type @c float
 370          */
 371         static float GetMinValue(void);
 372
 373         /**
 374          * A @c float value of this instance.
 375          *
 376          * @since       2.0
 377          */
 378         float value;
 379
 380
 381 private:
 382         /**
 383          *      Checks if the specified @c float value is finite.
 384          *
 385          *      @since          2.0
 386          *
 387          *      @return         @c true if the specified value is finite, @n
 388          *                              else @c false
 389          *      @param[in]      value   A @c float value to check
 390          */
 391         static bool IsFinite(float value);
 392
 393         static const int __DBL_MAX_10_EXP = 308;
 394
 395         friend class _FloatImpl;
 396         class _FloatImpl * __pFloatImpl;
 397
 398 }; // Float
 399
 400 }} // Tizen::Base
 401
 402 #endif //_FBASE_FLOAT_H_