src/base/FBaseInteger8.cpp

   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.cpp
  19  * @brief               This is the implementation file for Integer8 class.
  20  * @see                 Number class
  21  */
  22 #include <wchar.h>
  23 #include <errno.h>
  24 #include <limits.h>
  25 #include <FBaseInteger8.h>
  26 #include <FBaseResult.h>
  27 #include <FBaseCharacter.h>
  28 #include <FBaseSysLog.h>
  29 #include "FBase_NumberUtil.h"
  30 #include "FApp_AppInfo.h"
  31
  32 namespace Tizen { namespace Base
  33 {
  34
  35 Integer8::Integer8(void)
  36         : value(0)
  37         , __pInteger8Impl(null)
  38 {
  39 }
  40
  41 Integer8::Integer8(int8_t val)
  42         : value(val)
  43         , __pInteger8Impl(null)
  44 {
  45 }
  46
  47 Integer8::Integer8(const Integer8& rhs)
  48         : value(rhs.value)
  49         , __pInteger8Impl(null)
  50 {
  51 }
  52
  53 Integer8::~Integer8(void)
  54 {
  55 }
  56
  57 Integer8&
  58 Integer8::operator =(const Integer8& rhs)
  59 {
  60         if (&rhs != this)
  61         {
  62                 value = rhs.value;
  63         }
  64         return *this;
  65 }
  66
  67 int
  68 Integer8::Compare(int8_t i81, int8_t i82)
  69 {
  70         return i81 - i82;
  71 }
  72
  73 int
  74 Integer8::CompareTo(const Integer8& rhs) const
  75 {
  76         return Integer8::Compare(this->value, rhs.value);
  77 }
  78
  79 bool
  80 Integer8::Equals(const Object& obj) const
  81 {
  82         const Integer8* pOther = dynamic_cast< const Integer8* >(&obj);
  83         if (pOther == null)
  84         {
  85                 return false;
  86         }
  87
  88         return value == pOther->value;
  89 }
  90
  91 int
  92 Integer8::GetHashCode(void) const
  93 {
  94         return static_cast< int >(value);
  95 }
  96
  97 int
  98 Integer8::GetHashCode(int8_t val)
  99 {
 100         return static_cast< int >(val);
 101 }
 102
 103 result
 104 Integer8::Decode(const String& inputStr, int8_t& ret)
 105 {
 106         long value;
 107         result r = _NumberUtil::Decode(inputStr, value);
 108         SysTryReturnResult(NID_BASE, r == E_SUCCESS, r, "Propagating.");
 109         SysTryReturnResult(NID_BASE, (value >= Integer8::VALUE_MIN) && (value <= Integer8::VALUE_MAX), E_OUT_OF_RANGE, "The value(%d) is out of range.", value);
 110         ret = static_cast< int8_t >(value);
 111         return E_SUCCESS;
 112 }
 113
 114 result
 115 Integer8::Parse(const String& inputStr, int8_t& ret)
 116 {
 117         return Parse(inputStr, Character::RADIX_DECIMAL, ret);
 118 }
 119
 120 result
 121 Integer8::Parse(const String& inputStr, int radix, int8_t& ret)
 122 {
 123         long value;
 124         result r = _NumberUtil::Parse(inputStr, radix, value);
 125         SysTryReturnResult(NID_BASE, r == E_SUCCESS, r, "Propagating.");
 126         SysTryReturnResult(NID_BASE, (value >= Integer8::VALUE_MIN) && (value <= Integer8::VALUE_MAX), E_OUT_OF_RANGE, "The value(%d) is out of range.", value);
 127         ret = static_cast< int8_t >(value);
 128         return E_SUCCESS;
 129 }
 130
 131 char
 132 Integer8::ToChar(void) const
 133 {
 134         return static_cast< signed char >(value);
 135 }
 136
 137 short
 138 Integer8::ToShort(void) const
 139 {
 140         return static_cast< short >(value);
 141 }
 142
 143 int
 144 Integer8::ToInt(void) const
 145 {
 146         return static_cast< int >(value);
 147 }
 148
 149 long
 150 Integer8::ToLong(void) const
 151 {
 152         return static_cast< long >(value);
 153 }
 154
 155 long long
 156 Integer8::ToLongLong(void) const
 157 {
 158         return static_cast< long long >(value);
 159 }
 160
 161 float
 162 Integer8::ToFloat(void) const
 163 {
 164         return static_cast< float >(value);
 165 }
 166
 167 double
 168 Integer8::ToDouble(void) const
 169 {
 170         return static_cast< double >(value);
 171 }
 172
 173 String
 174 Integer8::ToString(void) const
 175 {
 176         return (Integer8::ToString(value));
 177 }
 178
 179 String
 180 Integer8::ToString(int8_t value)
 181 {
 182         const static unsigned int INTEGER8_LENGTH_MAX = 4;
 183
 184         wchar_t sValue[INTEGER8_LENGTH_MAX + 1] = {0, };
 185         swprintf(sValue, INTEGER8_LENGTH_MAX + 1, L"%d", value);
 186
 187         return String(sValue);
 188 }
 189
 190 }} //Tizen::Base