[ACR][20/08/2013][Add]Enhance Double::ToString() andFloat::ToString() to set a specif...

[platform/framework/native/appfw.git] / src / base / FBaseFloat.cpp

diff --git a/src/base/FBaseFloat.cpp b/src/base/FBaseFloat.cpp
index c6aba7d..7f24ae7 100644 (file)
--- a/src/base/FBaseFloat.cpp
+++ b/src/base/FBaseFloat.cpp
@@ -1,5 +1,4 @@
 //
-// Open Service Platform
 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
 //
 // Licensed under the Apache License, Version 2.0 (the License);
@@ -18,10 +17,8 @@
 /**
  * @file               FBaseFloat.cpp
  * @brief              This is the implementation file for Float class.
- * @see                        Number class
+ * @see                Number class
  */
-
-// Includes
 #include <cfloat>
 #include <math.h>
 #include <stdio.h>
@@ -31,6 +28,7 @@
 #include <FBaseFloat.h>
 #include <FBaseResult.h>
 #include <FBaseSysLog.h>
+#include "FBase_LocalizedNumParser.h"
 
 namespace Tizen { namespace Base
 {
@@ -108,7 +106,7 @@ Float::CompareTo(const Float& value) const
 bool
 Float::Equals(const Object& obj) const
 {
-       const Float* pOther = dynamic_cast <const Float*>(&obj);
+       const Float* pOther = dynamic_cast< const Float* >(&obj);
 
        if (pOther == null)
        {
@@ -128,31 +126,29 @@ Float::Equals(const Object& obj) const
 int
 Float::GetHashCode(void) const
 {
-       float* pTemp = const_cast<float*> (&value);
-       int* pValue = reinterpret_cast<int*> (pTemp);
+       float* pTemp = const_cast< float* >(&value);
+       int* pValue = reinterpret_cast< int* >(pTemp);
        return *pValue;
 }
 
 int
 Float::GetHashCode(float val)
 {
-       int* pValue = reinterpret_cast<int*> (&val);
+       int* pValue = reinterpret_cast< int* >(&val);
        return *pValue;
 }
 
 result
 Float::Parse(const String& s, float& ret)
 {
-       SysTryReturn(NID_BASE, s.GetLength() >= 1, E_NUM_FORMAT, E_NUM_FORMAT,
-               "[%s] The length of s MUST be greater than 0.", GetErrorMessage(E_NUM_FORMAT));
+       double tmpRet = _LocalizedNumParser::ToFloat(s, "");
 
-       errno = 0;
-       wchar_t* pEnd = null;
-       float tmpRet = wcstof(s.GetPointer(), &pEnd);
-       SysTryReturn(NID_BASE, (!Float::Compare(pEnd[0], 0)), E_NUM_FORMAT, E_NUM_FORMAT,
-               "[%s] Float parse failed. Scan stopped at (%ls).", GetErrorMessage(E_NUM_FORMAT), pEnd);
-       SysTryReturn(NID_BASE, !((!Float::Compare(tmpRet, HUGE_VAL) || !Float::Compare(tmpRet, -HUGE_VAL)) && (errno != 0)),
-               E_NUM_FORMAT, E_NUM_FORMAT, "[%s] Parsed value cannot fit into a Float.", GetErrorMessage(E_NUM_FORMAT));
+       if (IsNaN(tmpRet))
+       {
+               result r = GetLastResult();
+               SysLogException(NID_BASE, r, "[%s] Propagating.", GetErrorMessage(r));
+               return r;
+       }
 
        ret = tmpRet;
        return E_SUCCESS;
@@ -161,31 +157,31 @@ Float::Parse(const String& s, float& ret)
 char
 Float::ToChar(void) const
 {
-       return static_cast<char> (value);
+       return static_cast< char >(value);
 }
 
 short
 Float::ToShort(void) const
 {
-       return  static_cast<short> (value);
+       return static_cast< short >(value);
 }
 
 int
 Float::ToInt(void) const
 {
-       return static_cast<int> (value);
+       return static_cast< int >(value);
 }
 
 long
 Float::ToLong(void) const
 {
-       return static_cast<long> (value);
+       return static_cast< long >(value);
 }
 
 long long
 Float::ToLongLong(void) const
 {
-       return static_cast<long long> (value);
+       return static_cast< long long >(value);
 }
 
 float
@@ -197,38 +193,36 @@ Float::ToFloat(void) const
 double
 Float::ToDouble(void) const
 {
-       return static_cast<double> (value);
+       return static_cast< double >(value);
 }
 
 String
 Float::ToString(void) const
 {
-       return(Float::ToString(value));
+       return Float::ToString(value);
 }
 
 String
-Float::ToString(float value)
+Float::ToString(int precision) const
 {
-       const static unsigned int MAX_DIG = 7 + 3;
-       const static unsigned int FLOAT_LENGTH_MAX = __DBL_MAX_10_EXP + MAX_DIG;
+//Dummy implementation to resolve build break
+       return String(L"");
+}
 
-       if (Float::IsNaN(value))
-       {
-               return String(L"NaN");
-       }
-       else if (Float::IsInfinity(value))
-       {
-               return String(L"Infinity");
-       }
-       else
-       {
-               wchar_t sValue[FLOAT_LENGTH_MAX + 1] = {0, };
-               swprintf(sValue, (sizeof(sValue) / sizeof(sValue[0])), L"%g", value);
+String
+Float::ToString(float value)
+{
+       return _LocalizedNumParser::ToString(value, "");
+}
 
-               return String(sValue);
-       }
+String
+Float::ToString(float value, int precision)
+{
+//Dummy implementation to resolve build break
+       return String(L"");
 }
 
+
 int
 Float::ToBits(float value)
 {
@@ -248,31 +242,31 @@ Float::ToFloatFromBits(int value)
 bool
 Float::IsFinite(float value)
 {
-       return((isfinite(value) != 0) ? true : false);
+       return isfinite(value);
 }
 
 bool
 Float::IsInfinity(void) const
 {
-       return(Float::IsInfinity(value));
+       return Float::IsInfinity(value);
 }
 
 bool
 Float::IsInfinity(float value)
 {
-       return(!Float::IsFinite(value));
+       return !Float::IsFinite(value);
 }
 
 bool
 Float::IsNaN(void) const
 {
-       return(Float::IsNaN(value));
+       return Float::IsNaN(value);
 }
 
 bool
 Float::IsNaN(float value)
 {
-       return((isnan(value) != 0) ? true : false);
+       return isnan(value);
 }
 
 float