inc/FBaseLongLong.h

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file                FBaseLongLong.h
  19  * @brief               This is the header file for the %LongLong class.
  20  *
  21  * @see                 Tizen::Base::Number
  22  *
  23  * This header file contains the declarations of the %LongLong class.
  24  */
  25 #ifndef _FBASE_LONG_LONG_H_
  26 #define _FBASE_LONG_LONG_H_
  27
  28 #include <FBaseNumber.h>
  29
  30 namespace Tizen { namespace Base
  31 {
  32 /**
  33  *      @class  LongLong
  34  *      @brief  This class is the wrapper class for the @c signed @c long @c long built-in type.
  35  *
  36  *      @since  2.0
  37  *
  38  *      The %LongLong class represents an integer value ranging from -9223372036854775808 to 9223372036854775807
  39  *      , that is, -(2^63) to +((2^63)-1). The class is useful when passing a 64-bit @c signed
  40  *      integral value to a method that accepts only an instance of Object. Furthermore,
  41  *      this class provides methods for converting %LongLong (and @c long @c long) to String, and %String
  42  *      to %LongLong (and @c long @c long).
  43  *
  44  * The following example demonstrates how to use the %LongLong class.
  45  *
  46  *      @code
  47  *
  48  *      #include <FBase.h>
  49  *
  50  *      using namespace Tizen::Base;
  51  *
  52  *      // This method checks whether the given string object contains a string
  53  *      // representation of the pre-defined minimum 64-bit integral value
  54  *      result
  55  *      MyClass::Verify(String& string, bool& out)
  56  *      {
  57  *              static const LongLong MINIMUM(123456789);
  58  *              result r = E_SUCCESS;
  59  *
  60  *              long long l;
  61  *              r = LongLong::Parse(string, l);
  62  *              if (IsFailed(r))
  63  *              {
  64  *                      goto CATCH;
  65  *              }
  66  *
  67  *              out = (MINIMUM.CompareTo(l) == 0) ? true: false;
  68  *
  69  *              return r;
  70  *      CATCH:
  71  *              return r;
  72  *      }
  73  *      @endcode
  74  */
  75 class _OSP_EXPORT_ LongLong
  76         : public Number
  77 {
  78 public:
  79         /**
  80          *      Initializes this instance of %LongLong with the specified value.
  81          *
  82          *      @since                  2.0
  83          *
  84          *      @param[in]      value   A @c long @c long value
  85          */
  86         LongLong(long long value = 0);
  87
  88         /**
  89          *      Copying of objects using this copy constructor is allowed.
  90          *
  91          *      @since                  2.0
  92          *
  93          *      @param[in]      value   An instance of %LongLong
  94          */
  95         LongLong(const LongLong& value);
  96
  97         /**
  98          *      This destructor overrides Tizen::Base::Object::~Object().
  99          *
 100          *      @since  2.0
 101          */
 102         virtual ~LongLong(void);
 103
 104         /**
 105          *      Copying of objects using this copy assignment operator is allowed.
 106          *
 107          *      @since                  2.0
 108          *
 109          *      @param[in]      rhs     An instance of %LongLong
 110          */
 111         LongLong& operator =(const LongLong& rhs);
 112
 113         /**
 114          *      Compares two @c long @c long values.
 115          *
 116          *      @since          2.0
 117          *
 118          *      @return         A 32-bit @c signed integer value
 119          *      @code
 120          *      <  0  if the value of @c l1 is less than the value of @c l2
 121          *      == 0  if the value of @c l1 is equal to the value of @c l2
 122          *      >  0  if the value of @c l1 is greater than the value of @c l2
 123          *      @endcode
 124          *      @param[in]      l1      The first @c long @c long value to compare
 125          *      @param[in]      l2      The second @c long @c long value to compare
 126          */
 127         static int Compare(long long l1, long long l2);
 128
 129         /**
 130          *      Compares the value of the current instance with the value of the specified instance of the %LongLong class.
 131          *
 132          *      @since          2.0
 133          *
 134          *      @return         A 32-bit @c signed integer value
 135          *      @code
 136          *      <  0  if the value of the current instance is less than the value of the specified instance
 137          *      == 0  if the value of the current instance is equal to the value of the specified instance
 138          *      >  0  if the value of the current instance is greater than the value of the specified instance
 139          *      @endcode
 140          *      @param[in]      value   An instance of the %LongLong class to compare
 141          */
 142         int CompareTo(const LongLong& value) const;
 143
 144         /**
 145          *      Checks whether the value of the specified instance of Object is equal to the value of the current instance of %LongLong.
 146          *
 147          *      @since          2.0
 148          *
 149          *      @return         @c true if the value of the specified instance of Object is equal to the value of the current instance of %LongLong, @n
 150          *                              else @c false
 151          *      @param[in]      obj     An instance of Object to compare
 152          *      @see            Tizen::Base::Object::Equals()
 153          */
 154         virtual bool Equals(const Object& obj) const;
 155
 156         /**
 157          *      Gets the hash value of the current instance of %LongLong.
 158          *
 159          *      @since          2.0
 160          *
 161          *      @return         An integer value indicating the hash value of the current instance of %LongLong
 162          *      @remarks        Two equal instances must return the same hash value. For better performance,
 163          *                              the used hash function must generate a random distribution for all inputs. @n
 164          *                              The default implementation of this method returns the value of the current instance.
 165          */
 166         virtual int GetHashCode(void) const;
 167
 168         /**
 169         *        Gets the hash value of the specified @c long @c long value.
 170         *
 171         *        @since         2.0
 172         *
 173         *        @return                An integer value indicating the hash value of the specified @c long @c long value
 174         *        @param[in]   val   A @c long @c long value to get the hash value
 175         */
 176         static int GetHashCode(long long val);
 177
 178         /**
 179          *      Gets the @c char equivalent of the current instance of the %LongLong class.
 180          *
 181          *      @since          2.0
 182          *
 183          *      @brief  <i> [Deprecated] </i>
 184          *
 185          *      @deprecated     This method has portability issue.
 186          *                      Return value may not be @c signed @c char since char is treated as unsigned char in ARM architecture. @n
 187          *                      Use ToInt8() method to get @c int8_t
 188          *
 189          *      @return         The @c char equivalent of the current instance
 190          */
 191         virtual char ToChar(void) const;
 192
 193         /**
 194          *      Gets the @c int8_t equivalent of the current instance of %LongLong.
 195          *
 196          *      @since 3.0
 197          *
 198          *      @return The @c int8_t equivalent of the current instance
 199          *
 200          */
 201         virtual int8_t ToInt8(void) const;
 202
 203         /**
 204          *      Gets the @c signed @c short equivalent of the current instance of the %LongLong class.
 205          *
 206          *      @since          2.0
 207          *
 208          *      @return         The @c signed @c short equivalent of the current instance
 209          */
 210         virtual short ToShort(void) const;
 211
 212         /**
 213          *      Gets the @c signed @c int equivalent of the current instance of the %LongLong class.
 214          *
 215          *      @since          2.0
 216          *
 217          *      @return         The @c signed @c int equivalent of the current instance
 218          */
 219         virtual int ToInt(void) const;
 220
 221         /**
 222          *      Gets the @c signed @c long equivalent of the current instance of the %LongLong class.
 223          *
 224          *      @since          2.0
 225          *
 226          *      @return         The @c signed @c long equivalent of the current instance
 227          */
 228         virtual long ToLong(void) const;
 229
 230         /**
 231          *      Gets the @c signed @c float equivalent of the current instance of the %LongLong class.
 232          *
 233          *      @since          2.0
 234          *
 235          *      @return         The @c signed @c float equivalent of the current instance
 236          */
 237         virtual float ToFloat(void) const;
 238
 239         /**
 240          *      Gets the @c signed @c double equivalent of the current instance of the %LongLong class.
 241          *
 242          *      @since          2.0
 243          *
 244          *      @return         The @c signed @c double equivalent of the current instance
 245          */
 246         virtual double ToDouble(void) const;
 247
 248         /**
 249          *      Gets the @c signed @c long @c long equivalent of the current instance of the %LongLong class.
 250          *
 251          *      @since          2.0
 252          *
 253          *      @return         The @c signed @c long @c long equivalent of the current instance
 254          */
 255         virtual long long ToLongLong(void) const;
 256
 257         /**
 258          *      Gets the string representing the value of the current instance of the %LongLong class.
 259          *
 260          *      @since          2.0
 261          *
 262          *      @return         The string representing the value of the current instance
 263          */
 264         virtual String ToString(void) const;
 265
 266         /**
 267          *      Gets the string representing the specified @c signed @c long @c long value.
 268          *
 269          *      @since                  2.0
 270          *
 271          *      @return                         The string containing a Unicode representation of the specified @c signed @c long @c long value
 272          *      @param[in]      value   A @c signed @c long @c long value to convert
 273          */
 274         static String ToString(long long value);
 275
 276         /**
 277          * Decodes a string into a @c signed @c long @c long value.
 278          *
 279          * @since 3.0
 280          *
 281          * @return                      An error code
 282          * @param[in]   inputStr        A string representing a numeric value
 283          * @param[out]  ret             The result of the operation
 284          * @exception   E_SUCCESS       The method is successful.
 285          * @exception   E_NUM_FORMAT    The specified string does not contain a number that can be parsed.
 286          * @exception   E_OUT_OF_RANGE  The decoded value is not between VALUE_MIN and VALUE_MAX range.
 287          * @remarks
 288          *              - This method guarantees that the original value of out-parameter is not changed when the method returns error.
 289          *              - This method accepts decimal, hexadecimal, and octal numbers given by the
 290          *                              following grammar:
 291          * @code
 292          *      - DecodableString:
 293          *              Sign[opt] DecimalNumeral
 294          *              Sign[opt] 0x HexDigits
 295          *              Sign[opt] 0X HexDigits
 296          *              Sign[opt] # HexDigits
 297          *              Sign[opt] 0 OctalDigits
 298          *      - Sign:
 299          *              '-'
 300          * @endcode
 301          */
 302         static result Decode(const String& inputStr, long long& ret);
 303
 304         /**
 305          *      Parses the specified string representing a numeric value and
 306          *      returns the value as a @c signed @c long @c long (as out parameter).
 307          *
 308          *      @since                  2.0
 309          *
 310          *      @return                 An error code
 311          *      @param[in]      s                               A string representing a numeric value
 312          *      @param[out]     ret                             The result of the operation
 313          *      @exception      E_SUCCESS       The method is successful.
 314          *      @exception      E_NUM_FORMAT    The specified string does not contain a number that can be parsed.
 315          *      @exception      E_OUT_OF_RANGE  The parsed value is not between VALUE_MIN and VALUE_MAX range.
 316          *
 317          *      @remarks
 318          *                              - This method assumes that the string representing the numeric value uses a radix 10.
 319          *                              - This method guarantees that the original value of out-parameter is not changed when the method returns error.
 320          */
 321         static result Parse(const String& s, long long& ret);
 322
 323         /**
 324          *      Parses the specified string representing a numeric value using the specified radix and
 325          *      returns the value as a @c signed @c long @c long (as out parameter).
 326          *
 327          *      @since                  2.1
 328          *
 329          *      @return                 An error code
 330          *      @param[in]      s                               A string representing a numeric value
 331          *      @param[in]      radix                   The radix of the string representing a numeric value @n
 332          *                                              Radix value range is from 2 to 36.
 333          *      @param[out]     ret                             The result of the operation
 334          *      @exception      E_SUCCESS               The method is successful.
 335          *      @exception      E_NUM_FORMAT    The specified string does not contain a number that can be parsed.
 336          *      @exception      E_OUT_OF_RANGE  The specified @c radix is invalid or
 337          *                                      The parsed value is not between VALUE_MIN and VALUE_MAX range.
 338          *
 339          *      @remarks        This method guarantees that the original value of out-parameter is not changed when the method returns error.
 340          */
 341         static result Parse(const String& s, int radix, long long& ret);
 342
 343         /**
 344          *      A constant holding the maximum value a @c long @c long can have; 2^63-1.
 345          *
 346          *      @since  2.0
 347          */
 348         static const long long VALUE_MAX = static_cast< long long >(0x7FFFFFFFFFFFFFFFLL);
 349
 350         /**
 351          *      A constant holding the minimum value a @c long @c long can have; -2^63.
 352          *
 353          *      @since  2.0
 354          */
 355         static const long long VALUE_MIN = static_cast< long long >(0x8000000000000000LL);
 356
 357         /**
 358          * A @c long @c long value of this instance.
 359          *
 360          * @since       2.0
 361          */
 362         long long value;
 363
 364
 365 private:
 366         friend class _LongLongImpl;
 367         class _LongLongImpl* __pLongLongImpl;
 368
 369 }; // LongLong
 370
 371 }} // Tizen::Base
 372
 373 #endif //_FBASE_LONG_LONG_H_