src/base/FBaseFloat.cpp

   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                FBaseFloat.cpp
  19  * @brief               This is the implementation file for Float class.
  20  * @see         Number class
  21  */
  22
  23 // Includes
  24 #include <cfloat>
  25 #include <math.h>
  26 #include <stdio.h>
  27 #include <wchar.h>
  28 #include <errno.h>
  29 #include <limits.h>
  30 #include <FBaseFloat.h>
  31 #include <FBaseResult.h>
  32 #include <FBaseSysLog.h>
  33 #include "FBase_LocalizedNumParser.h"
  34
  35 namespace Tizen { namespace Base
  36 {
  37
  38 union FloatBitRep
  39 {
  40         explicit
  41         FloatBitRep(float f = 0.0)
  42                 : value(f)
  43         {
  44         };
  45
  46         FloatBitRep(unsigned int i)
  47                 : rep(i)
  48         {
  49         };
  50
  51         float value;
  52         unsigned int rep;
  53 };
  54
  55 Float::Float(float value)
  56         : value(value)
  57         , __pFloatImpl(null)
  58 {
  59 }
  60
  61 Float::Float(const Float& value)
  62         : value(value.value)
  63         , __pFloatImpl(null)
  64 {
  65 }
  66
  67 Float::~Float(void)
  68 {
  69 }
  70
  71 Float&
  72 Float::operator =(const Float& rhs)
  73 {
  74         if (&rhs != this)
  75         {
  76                 value = rhs.value;
  77         }
  78         return *this;
  79 }
  80
  81 int
  82 Float::Compare(float f1, float f2)
  83 {
  84         int ret = 0;
  85
  86         if (f1 > f2)
  87         {
  88                 ret = 1;
  89         }
  90         else if (f1 < f2)
  91         {
  92                 ret = -1;
  93         }
  94         else
  95         {
  96                 ret = 0;
  97         }
  98
  99         return ret;
 100 }
 101
 102 int
 103 Float::CompareTo(const Float& value) const
 104 {
 105         return(Float::Compare(this->value, value.value));
 106 }
 107
 108 bool
 109 Float::Equals(const Object& obj) const
 110 {
 111         const Float* pOther = dynamic_cast< const Float* >(&obj);
 112
 113         if (pOther == null)
 114         {
 115                 return false;
 116         }
 117
 118         if (Float::Compare(this->value, (*pOther).value) == 0)
 119         {
 120                 return true;
 121         }
 122         else
 123         {
 124                 return false;
 125         }
 126 }
 127
 128 int
 129 Float::GetHashCode(void) const
 130 {
 131         float* pTemp = const_cast< float* >(&value);
 132         int* pValue = reinterpret_cast< int* >(pTemp);
 133         return *pValue;
 134 }
 135
 136 int
 137 Float::GetHashCode(float val)
 138 {
 139         int* pValue = reinterpret_cast< int* >(&val);
 140         return *pValue;
 141 }
 142
 143 result
 144 Float::Parse(const String& s, float& ret)
 145 {
 146         double tmpRet = _LocalizedNumParser::ToFloat(s, "");
 147
 148         if (IsNaN(tmpRet))
 149         {
 150                 result r = GetLastResult();
 151                 SysLogException(NID_BASE, r, "[%s] Propagating.", GetErrorMessage(r));
 152                 return r;
 153         }
 154
 155         ret = tmpRet;
 156         return E_SUCCESS;
 157 }
 158
 159 char
 160 Float::ToChar(void) const
 161 {
 162         return static_cast< char >(value);
 163 }
 164
 165 short
 166 Float::ToShort(void) const
 167 {
 168         return static_cast< short >(value);
 169 }
 170
 171 int
 172 Float::ToInt(void) const
 173 {
 174         return static_cast< int >(value);
 175 }
 176
 177 long
 178 Float::ToLong(void) const
 179 {
 180         return static_cast< long >(value);
 181 }
 182
 183 long long
 184 Float::ToLongLong(void) const
 185 {
 186         return static_cast< long long >(value);
 187 }
 188
 189 float
 190 Float::ToFloat(void) const
 191 {
 192         return value;
 193 }
 194
 195 double
 196 Float::ToDouble(void) const
 197 {
 198         return static_cast< double >(value);
 199 }
 200
 201 String
 202 Float::ToString(void) const
 203 {
 204         return Float::ToString(value);
 205 }
 206
 207 String
 208 Float::ToString(float value)
 209 {
 210         return _LocalizedNumParser::ToString(value, "");
 211 }
 212
 213 int
 214 Float::ToBits(float value)
 215 {
 216         FloatBitRep bitRep;
 217         bitRep.value = value;
 218         return bitRep.rep;
 219 }
 220
 221 float
 222 Float::ToFloatFromBits(int value)
 223 {
 224         FloatBitRep bitRep;
 225         bitRep.rep = value;
 226         return bitRep.value;
 227 }
 228
 229 bool
 230 Float::IsFinite(float value)
 231 {
 232         return isfinite(value);
 233 }
 234
 235 bool
 236 Float::IsInfinity(void) const
 237 {
 238         return Float::IsInfinity(value);
 239 }
 240
 241 bool
 242 Float::IsInfinity(float value)
 243 {
 244         return !Float::IsFinite(value);
 245 }
 246
 247 bool
 248 Float::IsNaN(void) const
 249 {
 250         return Float::IsNaN(value);
 251 }
 252
 253 bool
 254 Float::IsNaN(float value)
 255 {
 256         return isnan(value);
 257 }
 258
 259 float
 260 Float::GetMaxValue(void)
 261 {
 262         return FLT_MAX;
 263 }
 264
 265 float
 266 Float::GetMinValue(void)
 267 {
 268         return FLT_MIN;
 269 }
 270
 271 }} // Tizen::Base