Fix ElementHandle::setAs.*Array methods

Direct accesses to array parameters were incorrectly identified, resulting in
an error when the client tried to set them. This was caused by a programming
mistake in using overloaded methods because `T`, `const T`, `T &` and `const
T&` are different. This is fixed by using the SFINAE principle and correctly
handing all the cases described above.

Signed-off-by: David Wagner <[email protected]>

Author: dawagner

parameter/ElementHandle.cpp

@@ -41,6 +41,36 @@ using std::string;
 using std::mutex;
 using std::lock_guard;
 
+template <class T>
+struct isVector : std::false_type
+{
+};
+
+template <class T>
+struct isVector<std::vector<T>> : std::true_type
+{
+};
+
+template <class T>
+struct remove_ref_cv
+{
+    using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+};
+
+template <class T>
+static typename std::enable_if<not isVector<typename remove_ref_cv<T>::type>::value,
+                               size_t>::type getUserInputSize(T /*values*/)
+{
+    return 0;
+}
+
+template <class T>
+static typename std::enable_if<isVector<typename remove_ref_cv<T>::type>::value, size_t>::type
+getUserInputSize(T values)
+{
+    return values.size();
+}
+
 ElementHandle::ElementHandle(CConfigurableElement &element, CParameterMgr &parameterMgr)
     : mElement(element), mParameterMgr(parameterMgr)
 {
@@ -137,27 +167,6 @@ bool ElementHandle::getStructureAsXML(std::string &xmlSettings, std::string &err
         CXmlParameterSerializingContext{accessContext, error}, xmlSettings);
 }
 
-template <class T>
-struct isVector : std::false_type
-{
-};
-template <class T>
-struct isVector<std::vector<T>> : std::true_type
-{
-};
-
-template <class T>
-size_t ElementHandle::getSize(T /*value*/)
-{
-    return 0;
-}
-
-template <class T>
-size_t ElementHandle::getSize(std::vector<T> &values)
-{
-    return values.size();
-}
-
 bool ElementHandle::getAsXML(std::string &xmlValue, std::string &error) const
 {
     std::string result;
@@ -194,7 +203,7 @@ bool ElementHandle::setAsBytes(const std::vector<uint8_t> &bytesValue, std::stri
 template <class T>
 bool ElementHandle::setAs(const T value, string &error) const
 {
-    if (not checkSetValidity(getSize(value), error)) {
+    if (not checkSetValidity(getUserInputSize(value), error)) {
         return false;
     }
     // Safe downcast thanks to isParameter check in checkSetValidity

parameter/include/ElementHandle.h

@@ -234,11 +234,6 @@ class PARAMETER_EXPORT ElementHandle
     template <class T>
     bool getAs(T &value, std::string &error) const;
 
-    template <class T>
-    static size_t getSize(T value);
-    template <class T>
-    static size_t getSize(std::vector<T> &values);
-
     CBaseParameter &getParameter();
     const CBaseParameter &getParameter() const;
 

test/functional-tests/Handle.cpp

@@ -602,4 +602,46 @@ SCENARIO("Mapping handle access", "[handler][mapping]")
     }
 }
 
+SCENARIO_METHOD(SettingsTestPF, "Handle Get/Set as various kinds", "[handler][dynamic]")
+{
+    ElementHandle intScalar(*this, "/test/test/parameter_block/integer");
+    WHEN ("Setting a scalar integer") {
+        WHEN ("As an array") {
+            THEN ("It should fail") {
+                CHECK_THROWS(intScalar.setAsIntegerArray({0, 0}));
+            }
+        }
+        WHEN ("As a scalalar") {
+            THEN ("It should succeed") {
+                uint32_t expected = 111;
+                CHECK_NOTHROW(intScalar.setAsInteger(expected));
+                AND_THEN ("Getting it back should give the same value") {
+                    uint32_t back = 42;
+                    CHECK_NOTHROW(intScalar.getAsInteger(back));
+                    CHECK(back == expected);
+                }
+            }
+        }
+    }
+
+    ElementHandle intArray(*this, "/test/test/parameter_block/integer_array");
+    WHEN ("Setting a array integer") {
+        WHEN ("As a scalar") {
+            THEN ("It should fail") {
+                CHECK_THROWS(intArray.setAsSignedInteger(0));
+            }
+        }
+        WHEN ("As a integer") {
+            THEN ("It should succeed") {
+                const std::vector<int32_t> expected = {-9, 8, -7, 6};
+                CHECK_NOTHROW(intArray.setAsSignedIntegerArray(expected));
+                AND_THEN ("Getting it back should give the same value") {
+                    std::vector<int32_t> back = {-42, 42, 43, -43};
+                    CHECK_NOTHROW(intArray.getAsSignedIntegerArray(back));
+                    CHECK(back == expected);
+                }
+            }
+        }
+    }
+}
 } // namespace parameterFramework

test/functional-tests/include/ElementHandle.hpp

@@ -76,6 +76,28 @@ class ElementHandle : private FailureWrapper<::ElementHandle>
     /** Wrap EH::getAsDouble to throw an exception on failure. */
     void getAsDouble(double &value) const { mayFailCall(&EH::getAsDouble, value); }
 
+    void setAsInteger(uint32_t value) { mayFailCall(&EH::setAsInteger, value); }
+    void getAsInteger(uint32_t &value) const { mayFailCall(&EH::getAsInteger, value); }
+    void setAsIntegerArray(const std::vector<uint32_t> &value)
+    {
+        mayFailCall(&EH::setAsIntegerArray, value);
+    }
+    void getAsIntegerArray(std::vector<uint32_t> &value) const
+    {
+        mayFailCall(&EH::getAsIntegerArray, value);
+    }
+
+    void setAsSignedInteger(int32_t value) { mayFailCall(&EH::setAsSignedInteger, value); }
+    void getAsSignedInteger(int32_t &value) const { mayFailCall(&EH::getAsSignedInteger, value); }
+    void setAsSignedIntegerArray(const std::vector<int32_t> &value)
+    {
+        mayFailCall(&EH::setAsSignedIntegerArray, value);
+    }
+    void getAsSignedIntegerArray(std::vector<int32_t> &value) const
+    {
+        mayFailCall(&EH::getAsSignedIntegerArray, value);
+    }
+
     std::string getStructureAsXML() const { return mayFailGet(&EH::getStructureAsXML); }
 
     std::string getAsXML() const { return mayFailGet(&EH::getAsXML); }