src/base/FBaseShort.cpp

   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                FBaseShort.cpp
  20  * @brief               This is the implementation file for Short class.
  21  * @see                 Number
  22  */
  23
  24 #include <wchar.h>
  25 #include <limits.h>
  26 #include <errno.h>
  27 #include <FBaseShort.h>
  28 #include <FBaseResult.h>
  29 #include <FBaseCharacter.h>
  30 #include <FBaseSysLog.h>
  31
  32 namespace Tizen { namespace Base
  33 {
  34
  35 Short::Short(short value)
  36         : value(value)
  37         , __pShortImpl(null)
  38 {
  39 }
  40
  41 Short::Short(const Short& value)
  42         : value(value.value)
  43         , __pShortImpl(null)
  44 {
  45 }
  46
  47 Short::~Short(void)
  48 {
  49 }
  50
  51 Short&
  52 Short::operator =(const Short& rhs)
  53 {
  54         if (&rhs != this)
  55         {
  56                 value = rhs.value;
  57         }
  58         return *this;
  59 }
  60
  61 int
  62 Short::Compare(short s1, short s2)
  63 {
  64         return(s1 < s2 ? -1 : (s1 == s2 ? 0 : 1));
  65 }
  66
  67 int
  68 Short::CompareTo(const Short& value) const
  69 {
  70         return(Short::Compare(this->value, value.value));
  71 }
  72
  73 bool
  74 Short::Equals(const Object& obj) const
  75 {
  76         const Short* pOther = dynamic_cast <const Short*>(&obj);
  77         if (pOther == null)
  78         {
  79                 return false;
  80         }
  81
  82         return value == (*pOther).value;
  83 }
  84
  85 bool
  86 Short::Equals(short value) const
  87 {
  88         return this->value == value;
  89 }
  90
  91 int
  92 Short::GetHashCode(void) const
  93 {
  94         return static_cast<int> (value);
  95 }
  96
  97 int
  98 Short::GetHashCode(short val)
  99 {
 100         return static_cast<int> (val);
 101 }
 102
 103 result
 104 Short::Decode(const String& s, short& ret)
 105 {
 106         SysTryReturn(NID_BASE, s.GetLength() >= 1, E_NUM_FORMAT, E_NUM_FORMAT,
 107                 "[%s] The length of s MUST be greater than 0.", GetErrorMessage(E_NUM_FORMAT));
 108
 109         long value = 0;
 110         int radix = 0;
 111         int startIndex = 0;
 112         int minLength = 2;
 113         wchar_t* pEnd = null;
 114         String str(s);
 115
 116         if (s[0] == L'-' || s[0] == L'+')
 117         {
 118                 startIndex = 1;
 119                 minLength = 3;
 120         }
 121
 122         // Find radix
 123         if (s[startIndex] == L'#')
 124         {
 125                 radix = Character::RADIX_HEXADECIMAL;
 126
 127                 // Remove '#'
 128                 str.Remove(startIndex, 1);
 129         }
 130         else if (s[startIndex] == L'0' && (s.GetLength() >= minLength))
 131         {
 132                 if (s[startIndex + 1] == L'x' || s[startIndex + 1] == L'X')
 133                 {
 134                         radix = Character::RADIX_HEXADECIMAL;
 135                 }
 136                 else
 137                 {
 138                         radix = Character::RADIX_OCTAL;
 139                 }
 140         }
 141         else
 142         {
 143                 radix = Character::RADIX_DECIMAL;
 144         }
 145
 146         result r = E_SUCCESS;
 147
 148         errno = 0;
 149         value = wcstol(str.GetPointer(), &pEnd, radix);
 150         SysTryCatch(NID_BASE, (pEnd[0] == 0), r = E_NUM_FORMAT, E_NUM_FORMAT,
 151                 "[%s] Short decode failed. Scan stopped at (%ls).", GetErrorMessage(E_NUM_FORMAT), pEnd);
 152         SysTryCatch(NID_BASE, !((value == LONG_MAX || value == LONG_MIN) && (errno != 0)), r = E_NUM_FORMAT, E_NUM_FORMAT,
 153                 "[%s] Decoded value cannot fit into Short.", GetErrorMessage(E_NUM_FORMAT));
 154
 155 CATCH:
 156         if (value > Short::VALUE_MAX)
 157         {
 158                 ret = Short::VALUE_MAX;
 159         }
 160         else if (value < Short::VALUE_MIN)
 161         {
 162                 ret = Short::VALUE_MIN;
 163         }
 164         else
 165         {
 166                 ret = (short) value;
 167         }
 168
 169         return r;
 170 }
 171
 172 result
 173 Short::Parse(const String& s, short& ret)
 174 {
 175         int len = s.GetLength();
 176         SysTryReturn(NID_BASE, (len > 0 && len < 7), E_NUM_FORMAT, E_NUM_FORMAT,
 177                 "[%s] The length of s(%ls) MUST be greater than 0 and less than 7.", GetErrorMessage(E_NUM_FORMAT), s.GetPointer());
 178
 179         return Parse(s, Character::RADIX_DECIMAL, ret);
 180 }
 181
 182 result
 183 Short::Parse(const String& s, int radix, short& ret)
 184 {
 185         SysTryReturn(NID_BASE, ((radix == Character::RADIX_BINARY) || (radix == Character::RADIX_OCTAL) ||
 186                 (radix == Character::RADIX_DECIMAL) || (radix == Character::RADIX_HEXADECIMAL)), E_OUT_OF_RANGE, E_OUT_OF_RANGE,
 187                 "[%s] The radix(%d) MUST be one of 2, 8, 10 and 16.", GetErrorMessage(E_OUT_OF_RANGE), radix);
 188
 189         int len = s.GetLength();
 190         SysTryReturn(NID_BASE, (len > 0), E_NUM_FORMAT, E_NUM_FORMAT, "[%s] The length of s MUST be greater than 0.",
 191                 GetErrorMessage(E_NUM_FORMAT));
 192
 193         result r = E_SUCCESS;
 194
 195         errno = 0;
 196         wchar_t* pEnd = null;
 197         long value = wcstol(s.GetPointer(), &pEnd, radix);
 198         SysTryReturn(NID_BASE, (pEnd[0] == 0), E_NUM_FORMAT, E_NUM_FORMAT,
 199                 "[%s] Short parse failed. Scan stopped at (%ls).", GetErrorMessage(E_NUM_FORMAT), pEnd);
 200         SysTryReturn(NID_BASE, !(value > Short::VALUE_MAX || value < Short::VALUE_MIN) || (errno != 0), E_NUM_FORMAT,
 201                 E_NUM_FORMAT, "[%s] Parsed value cannot fit into Short.", GetErrorMessage(E_NUM_FORMAT));
 202
 203         if (value > Short::VALUE_MAX)
 204         {
 205                 ret = Short::VALUE_MAX;
 206         }
 207         else if (value < Short::VALUE_MIN)
 208         {
 209                 ret = Short::VALUE_MIN;
 210         }
 211         else
 212         {
 213                 ret = static_cast< short >(value);
 214         }
 215
 216         return r;
 217 }
 218
 219 char
 220 Short::ToChar(void) const
 221 {
 222         return static_cast<char> (value);
 223 }
 224
 225 short
 226 Short::ToShort(void) const
 227 {
 228         return value;
 229 }
 230
 231 int
 232 Short::ToInt(void) const
 233 {
 234         return static_cast<int> (value);
 235 }
 236
 237 long
 238 Short::ToLong(void) const
 239 {
 240         return static_cast<long> (value);
 241 }
 242
 243 long long
 244 Short::ToLongLong(void) const
 245 {
 246         return static_cast<long long> (value);
 247 }
 248
 249 float
 250 Short::ToFloat(void) const
 251 {
 252         return static_cast<float> (value);
 253 }
 254
 255 double
 256 Short::ToDouble(void) const
 257 {
 258         return static_cast<double> (value);
 259 }
 260
 261 String
 262 Short::ToString(void) const
 263 {
 264         return(Short::ToString(value));
 265 }
 266
 267 String
 268 Short::ToString(short value)
 269 {
 270         const static unsigned int SHORT_LENGTH_MAX = 6;
 271
 272         wchar_t sValue[SHORT_LENGTH_MAX + 1] = {0, };
 273         swprintf(sValue, (sizeof(sValue) / sizeof(sValue[0])), L"%d", value);
 274
 275         return String(sValue);
 276 }
 277
 278 }} //Tizen::Base