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