inc/FBaseInteger8.h

   1 //
   2 // Copyright (c) 2013 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                FBaseInteger8.h
  19  * @brief               This is the header file for the %Integer8 class.
  20  *
  21  * @see                 Tizen::Base::Number
  22  *
  23  * This header file contains the declarations of the %Integer8 class.
  24  */
  25 #ifndef _FBASE_INTEGER8_H_
  26 #define _FBASE_INTEGER8_H_
  27
  28 #include <stdint.h>
  29 #include <FBaseNumber.h>
  30
  31 namespace Tizen { namespace Base
  32 {
  33 /**
  34  * @class       Integer8
  35  * @brief       This class is the wrapper class for the  @c 8-bits integral built-in type @c int8_t.
  36  *
  37  * @since 3.0
  38  *
  39  * The %Integer8 class represents an integer value ranging from -128 to 127. The class is useful when passing an 8-bit
  40  * signed integral value to a method that accepts only an instance of Object. Furthermore, this class provides
  41  * methods for converting %Integer8 (and @c char) to String, and %String to %Integer8 (and @c char).
  42  *
  43  * The following example demonstrates how to use the %Integer8 class.
  44  * @code
  45  *
  46  *      #include <FBase.h>
  47  *
  48  *      using namespace Tizen::Base;
  49  *
  50  *      // This method checks whether the given string object contains a string
  51  *      // representation of the pre-defined minimum 8-bit integral value.
  52  *      result
  53  *      MyClass::Verify(String& string, bool& out)
  54  *      {
  55  *              static const Integer8 i1(123);
  56  *
  57  *              int8_t int8Val;
  58  *              result r = Integer8::Parse(string, int8Val);
  59  *              static const Integer8 i2(int8Val);
  60  *              if (!IsFailed(r))
  61  *              {
  62  *                      out = (i1.CompareTo(i2) == 0) ? true: false;
  63  *              }
  64  *
  65  *              return r;
  66  *      }
  67  * @endcode
  68  */
  69 class _OSP_EXPORT_ Integer8
  70         : public Number
  71 {
  72 public:
  73         /**
  74          * This is the default constructor for this class. Initializes the value to 0.
  75          *
  76          * @since 3.0
  77          *
  78          */
  79         Integer8();
  80
  81         /**
  82          * Initializes this instance of %Integer8 with the specified value.
  83          *
  84          * @since 3.0
  85          *
  86          * @param[in]   value   A @c signed 8-bits integral @c int8_t value
  87          */
  88         explicit Integer8(int8_t value);
  89
  90
  91         /**
  92          * Copying of objects using this copy constructor is allowed.
  93          *
  94          * @since 3.0
  95          *
  96          * @param[in]   value   An instance of %Integer8
  97          */
  98         Integer8(const Integer8& value);
  99
 100         /**
 101          * This destructor overrides Tizen::Base::Object::~Object().
 102          *
 103          * @since 3.0
 104          */
 105         virtual ~Integer8(void);
 106
 107         /**
 108          * Copying of objects using this copy assignment operator is allowed.
 109          *
 110          * @since 3.0
 111          *
 112          * @param[in]   rhs     An instance of %Integer8
 113          */
 114         Integer8& operator =(const Integer8& rhs);
 115
 116         /**
 117          * Compares two @c signed 8-bits integral @c int8_t values.
 118          *
 119          * @since 3.0
 120          *
 121          * @return              A 32-bit @c signed integr value
 122          * @code
 123          * <  0  if the value of i81 is less than the value of i82
 124          * == 0  if the value of i81 is equal to the value of i82
 125          * >  0  if the value of i81 is greater than the value of i82
 126          * @endcode
 127          * @param[in]   i81     The first @c signed 8-bits integral @c int8_t value to compare
 128          * @param[in]   i82     The second @c signed 8-bits integral @c int8_t value to compare
 129          */
 130         static int Compare(int8_t i81, int8_t i82);
 131
 132         /**
 133          * Compares the value of the current instance with the value of the specified instance of the %Integer8 class.
 134          *
 135          * @since 3.0
 136          *
 137          * @return              A 32-bit @c signed integer value
 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 %Integer8 class to compare
 144          */
 145         int CompareTo(const Integer8& value) const;
 146
 147         /**
 148          * Checks whether the value of the specified instance of %Integer8 is equal to the value of the current instance.
 149          *
 150          * @since 3.0
 151          *
 152          * @return              @c true if the value of the specified instance is equal to the value of the current instance, @n
 153          *                              else @c false
 154          * @param[in]   obj An instance of Object to compare
 155          * @see                 Tizen::Base::Object::Equals()
 156          */
 157         virtual bool Equals(const Object& obj) const;
 158
 159         /**
 160          *      Gets the hash value of the current instance of %Integer8.
 161          *
 162          *      @since 3.0
 163          *
 164          *      @return         An integer value indicating the hash value of the current instance of %Integer8
 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 signed 8-bits integral @c int8_t value.
 173         *
 174         *   @since 3.0
 175         *
 176         *   @return     An integer value indicating the hash value of the specified @c signed 8-bits integral @c int8_t value
 177         *   @param[in]   val   A @c signed 8-bits integral @c int8_t value to get the hash value
 178         */
 179         static int GetHashCode(int8_t val);
 180
 181         /**
 182          * Decodes a string into a @c signed 8-bits integral @c int8_t value.
 183          *
 184          * @since 3.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, int8_t& ret);
 205
 206         /**
 207          * Parses the specified string representing a @c signed 8-bits integral @c int8_t value and
 208          * returns the value as @c signed 8-bits integral @c int8_t (as out parameter).
 209          * @since 3.0
 210          *
 211          * @return              An error code
 212          * @param[in]   s       A string representing a numeric value
 213          * @param[out]  ret     The @c signed 8-bits integral @c int8_t equivalent of the specified string representing the numeric value using the decimal radix.
 214          * @exception   E_SUCCESS        The method is successful.
 215          * @exception   E_NUM_FORMAT The specified string does not contain a byte that can be parsed.
 216          * @remarks
 217          *                              - This method assumes that the string representing the @c signed 8-bits integral value uses a radix 10.
 218          *                              - This method guarantees that the original value of out-parameter is not changed when the method returns error.
 219          */
 220         static result Parse(const String& s, int8_t& ret);
 221
 222         /**
 223          * Parses the specified string representing a @c signed 8-bits integral @c int8_t value and
 224          * returns the value as @c signed 8-bits integral @c int8_t (as out parameter).
 225          *
 226          * @since 3.0
 227          *
 228          * @return              An error code
 229          * @param[in]   s       A string representing a @c signed 8-bits integral value
 230          * @param[in]   radix   The radix of the string representing a numeric value. Radix value range is from 2 to 36.
 231          * @param[out]  ret     The @c signed 8-bits integral @c int8_t equivalent of the specified string representing the numeric value using the specified radix
 232          * @exception   E_SUCCESS        The method is successful.
 233          * @exception   E_NUM_FORMAT The specified string does not contain a number that can be parsed.
 234          * @exception   E_OUT_OF_RANGE The specified @c radix is invalid.
 235          * @remarks             This method guarantees that the original value of out-parameter is not changed when the method returns error.
 236          */
 237         static result Parse(const String& s, int radix, int8_t& ret);
 238
 239         /**
 240          * Gets the @c signed @c char equivalent of the current instance of %Integer8.
 241          *
 242          * @since 3.0
 243          *
 244          * @return      The @c signed @c char equivalent of the current instance
 245          * @remarks     This method has portability issue. Return value may not be @c signed @c char since char is treated as unsigned char in ARM architecture. @n
 246          *
 247          */
 248         virtual char ToChar(void) const;
 249
 250         /**
 251          * Gets the @c signed @c short equivalent of the current instance of %Integer8.
 252          *
 253          * @since 3.0
 254          *
 255          * @return      The @c signed @c short equivalent of the current instance
 256          */
 257         virtual short ToShort(void) const;
 258
 259         /**
 260          * Gets the @c signed @c int equivalent of the current instance of %Integer8.
 261          *
 262          * @since 3.0
 263          *
 264          * @return      The @c signed @c int equivalent of the current instance
 265          */
 266         virtual int ToInt(void) const;
 267
 268         /**
 269          * Gets the @c signed @c long equivalent of the current instance of %Integer8.
 270          *
 271          * @since 3.0
 272          *
 273          * @return      The @c signed @c long equivalent of the current instance
 274          */
 275         virtual long ToLong(void) const;
 276
 277         /**
 278         * Gets the @c signed @c long @c long equivalent of the current instance of %Integer8.
 279         *
 280         * @since 3.0
 281         *
 282         * @return       The @c signed @c long @c long equivalent of the current instance
 283         */
 284         virtual long long ToLongLong(void) const;
 285
 286         /**
 287          * Gets the @c signed @c float equivalent of the current instance of %Integer8.
 288          *
 289          * @since 3.0
 290          *
 291          * @return      The @c signed @c float equivalent of the current instance
 292          */
 293         virtual float ToFloat(void) const;
 294
 295         /**
 296          * Gets the @c signed @c double equivalent of the current instance of %Integer8.
 297          *
 298          * @since 3.0
 299          *
 300          * @return      The @c signed @c double equivalent of the current instance
 301          */
 302         virtual double ToDouble(void) const;
 303
 304         /**
 305          * Gets the string representing the value of the current instance of %Integer8 using radix @c 10.
 306          *
 307          * @since 3.0
 308          *
 309          * @return              A string representing the value of the current instance using radix 10
 310          */
 311         virtual String ToString(void) const;
 312
 313         /**
 314          * Gets the string representing the specified @c signed 8-bits integral @c int8_t value using radix @c 10.
 315          *
 316          * @since 3.0
 317          *
 318          * @return              A string containing a Unicode representation of the specified @c signed 8-bits integral @c int8_t value using radix 10
 319          * @param[in]   value   A @c signed 8-bits integral @c int8_t value
 320          */
 321         static String ToString(int8_t value);
 322
 323         /**
 324          * A constant holding the maximum value of type @c signed 8-bits integral value. @n
 325          * A @c signed 8-bits integral can hold a maximum value of upto 2^7-1.
 326          *
 327          * @since 3.0
 328          */
 329         static const int8_t VALUE_MAX = static_cast<int8_t> (0x7F);
 330
 331         /**
 332          * A constant holding the minimum value of type @c signed 8-bits integral value. @n
 333          * A @c signed 8-bits integral can hold a minimum value of upto -2^7.
 334          *
 335          * @since 3.0
 336          */
 337         static const int8_t VALUE_MIN = static_cast<int8_t> (0x80);
 338
 339         /**
 340          * A @c signed @c signed 8-bits integral value of this instance.
 341          *
 342          * @since 3.0
 343          */
 344         int8_t value;
 345
 346
 347 private:
 348         friend class _Integer8Impl;
 349         class _Integer8Impl* __pInteger8Impl;
 350
 351 }; // Integer8
 352
 353 }} // Tizen::Base
 354
 355 #endif //_FBASE_INTEGER8_H_