FixedPointParameterType: fix potential compilation issue

BZ: 176178

The isEncodable() method has several prototypes and some compilers are not able
to decide which version to use and produce a compilation error.

Remove unnecessary casts and make the code simpler by using a template-based
conversion library from string to various numeric types instead of using
strtoll and strtod.

Change-Id: I53d0b4ebd12f2cbb315bb52d98365a35876b5aef
Signed-off-by: David Wagner <david.wagner@intel.com>
Signed-off-by: Mattijs Korpershoek <mattijsx.korpershoek@intel.com>

2 files changed, 95 insertions, 41 deletions

diff --git a/parameter/FixedPointParameterType.cpp b/parameter/FixedPointParameterType.cpp
index 88d3aa1..6a873b3 100644
--- a/parameter/FixedPointParameterType.cpp
+++ b/parameter/FixedPointParameterType.cpp
@@ -37,6 +37,7 @@
 #include "ParameterAccessContext.h"
 #include "ConfigurationAccessContext.h"
 #include <errno.h>
+#include <convert.hpp>
 
 #define base CParameterType
 
@@ -122,19 +123,11 @@ bool CFixedPointParameterType::toBlackboard(const string& strValue, uint32_t& ui
         return false;
     }
 
-    int64_t iData;
+    uint32_t uiData;
 
     if (parameterAccessContext.valueSpaceIsRaw()) {
-        errno = 0;
-        char *pcStrEnd;
 
-        // Get data in integer form
-        iData = strtoll(strValue.c_str(), &pcStrEnd, 0);
-
-        // Conversion error when the input string does not contain any digit or the number is out of range
-        bool bConversionSucceeded = !errno && (strValue.c_str() != pcStrEnd);
-
-        if (!bConversionSucceeded || !isEncodable((uint64_t)iData, !bValueProvidedAsHexa)) {
+        if (!convertTo(strValue, uiData) || !isEncodable(uiData, !bValueProvidedAsHexa)) {
 
             // Illegal value provided
             parameterAccessContext.setError(getOutOfRangeError(strValue, parameterAccessContext.valueSpaceIsRaw(), bValueProvidedAsHexa));
@@ -144,20 +137,14 @@ bool CFixedPointParameterType::toBlackboard(const string& strValue, uint32_t& ui
         if (bValueProvidedAsHexa) {
 
             // Sign extend
-            signExtend(iData);
+            signExtend((int32_t&)uiData);
         }
 
     } else {
-        errno = 0;
-        char *pcStrEnd;
-
-        double dData = strtod(strValue.c_str(), &pcStrEnd);
-
-        // Conversion error when the input string does not contain any digit or the number is out of range (int32_t type)
-        bool bConversionSucceeded = !errno && (strValue.c_str() != pcStrEnd);
+        double dData;
 
         // Check encodability
-        if (!bConversionSucceeded || !checkValueAgainstRange(dData)) {
+        if (!convertTo(strValue, dData) || !checkValueAgainstRange(dData)) {
 
             // Illegal value provided
             parameterAccessContext.setError(getOutOfRangeError(strValue, parameterAccessContext.valueSpaceIsRaw(), bValueProvidedAsHexa));
@@ -166,13 +153,13 @@ bool CFixedPointParameterType::toBlackboard(const string& strValue, uint32_t& ui
         }
 
         // Do the conversion
-        iData = asInteger(dData);
+        uiData = (uint32_t)asInteger(dData);
     }
 
     // check that the data is encodable and can be safely written to the blackboard
-    assert(isEncodable((unsigned long int)iData, true));
+    assert(isEncodable(uiData, true));
 
-    uiValue = (uint32_t)iData;
+    uiValue = uiData;
 
     return true;
 }
diff --git a/utility/convert.hpp b/utility/convert.hpp
index 273abd5..55146f7 100755
--- a/utility/convert.hpp
+++ b/utility/convert.hpp
@@ -34,6 +34,7 @@
 #include <sstream>
 #include <string>
 #include <stdint.h>
+#include <cmath>
 
 /* details namespace is here to hide implementation details to header end user. It
  * is NOT intended to be used outside. */
@@ -53,32 +54,15 @@ template<> struct ConvertionAllowed<int32_t> {};
 template<> struct ConvertionAllowed<uint16_t> {};
 template<> struct ConvertionAllowed<int16_t> {};
 template<> struct ConvertionAllowed<float> {};
+template<> struct ConvertionAllowed<double> {};
 
-} // namespace details
-
-/**
- * Convert a string to a given type.
- *
- * This template function read the value of the type T in the given string.
- * The function does not allow to have white spaces around the value to parse
- * and tries to parse the whole string, which means that if some bytes were not
- * read in the string, the function fails.
- * Hexadecimal representation (ie numbers starting with 0x) is supported only
- * for integral types conversions.
- * Result may be modified, even in case of failure.
- *
- * @param[in]  str    the string to parse.
- * @param[out] result reference to object where to store the result.
- *
- * @return true if conversion was successful, false otherwise.
- */
 template<typename T>
 static inline bool convertTo(const std::string &str, T &result)
 {
     /* Check that conversion to that type is allowed.
      * If this fails, this means that this template was not intended to be used
      * with this type, thus that the result is undefined. */
-    details::ConvertionAllowed<T>();
+    ConvertionAllowed<T>();
 
     if (str.find_first_of(std::string("\r\n\t\v ")) != std::string::npos) {
         return false;
@@ -110,6 +94,29 @@ static inline bool convertTo(const std::string &str, T &result)
 
     return ss.eof() && !ss.fail() && !ss.bad();
 }
+} // namespace details
+
+/**
+ * Convert a string to a given type.
+ *
+ * This template function read the value of the type T in the given string.
+ * The function does not allow to have white spaces around the value to parse
+ * and tries to parse the whole string, which means that if some bytes were not
+ * read in the string, the function fails.
+ * Hexadecimal representation (ie numbers starting with 0x) is supported only
+ * for integral types conversions.
+ * Result may be modified, even in case of failure.
+ *
+ * @param[in]  str    the string to parse.
+ * @param[out] result reference to object where to store the result.
+ *
+ * @return true if conversion was successful, false otherwise.
+ */
+template<typename T>
+static inline bool convertTo(const std::string &str, T &result)
+{
+    return details::convertTo<T>(str, result);
+}
 
 /**
  * Specialization for int16_t of convertTo template function.
@@ -143,6 +150,66 @@ inline bool convertTo<int16_t>(const std::string &str, int16_t &result)
 }
 
 /**
+ * Specialization for float of convertTo template function.
+ *
+ * This function follows the same paradigm than it's generic version and is
+ * based on it but makes furthers checks on the returned value.
+ *
+ * The specific implementation is made necessary because the stlport conversion
+ * from string to float behaves differently than GNU STL: overflow produce
+ * +/-Infinity rather than an error.
+ *
+ * @param[in]  str    the string to parse.
+ * @param[out] result reference to object where to store the result.
+ *
+ * @return true if conversion was successful, false otherwise.
+ */
+template<>
+inline bool convertTo<float>(const std::string &str, float &result)
+{
+    if (!details::convertTo(str, result)) {
+        return false;
+    }
+
+    if (std::abs(result) == std::numeric_limits<float>::infinity() ||
+        result == std::numeric_limits<float>::quiet_NaN()) {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * Specialization for double of convertTo template function.
+ *
+ * This function follows the same paradigm than it's generic version and is
+ * based on it but makes furthers checks on the returned value.
+ *
+ * The specific implementation is made necessary because the stlport conversion
+ * from string to double behaves differently than GNU STL: overflow produce
+ * +/-Infinity rather than an error.
+ *
+ * @param[in]  str    the string to parse.
+ * @param[out] result reference to object where to store the result.
+ *
+ * @return true if conversion was successful, false otherwise.
+ */
+template<>
+inline bool convertTo<double>(const std::string &str, double &result)
+{
+    if (!details::convertTo(str, result)) {
+        return false;
+    }
+
+    if (std::abs(result) == std::numeric_limits<double>::infinity() ||
+        result == std::numeric_limits<double>::quiet_NaN()) {
+        return false;
+    }
+
+    return true;
+}
+
+/**
  * Specialization for boolean of convertTo template function.
  *
  * This function follows the same paradigm than it's generic version.