feat: type check on bound function parameters solves #18

Author: eigen-value

src/rpclite_utils.h

@@ -19,6 +19,7 @@
 namespace RpcUtils {
 namespace detail {
 
+#define TYPE_ERROR      (-1)
 #define WRONG_MSG       (-2)
 #define NO_MSG          (-1)
 #define CALL_MSG        0
@@ -165,10 +166,10 @@ inline bool unpackObject(MsgPack::Unpacker& unpacker){
 }
 
 template<typename T>
-inline bool deserialize_single(MsgPack::Unpacker& unpacker, T& value) {
-    if (!unpacker.unpackable(value)) return false;
+int deserialize_single(MsgPack::Unpacker& unpacker, T& value) {
+    if (!unpacker.unpackable(value)) return TYPE_ERROR;
     unpacker.deserialize(value);
-    return true;
+    return 0;
 }
 
 
@@ -177,21 +178,22 @@ inline bool deserialize_single(MsgPack::Unpacker& unpacker, T& value) {
 /////////////////////////////
 
 template<std::size_t I = 0, typename... Ts>
-inline typename std::enable_if<I == sizeof...(Ts), bool>::type
+typename std::enable_if<I == sizeof...(Ts), int>::type
 deserialize_tuple(MsgPack::Unpacker&, std::tuple<Ts...>&) {
-    return true;
+    return 0;
 }
 
 template<std::size_t I = 0, typename... Ts>
-inline typename std::enable_if<I < sizeof...(Ts), bool>::type
+typename std::enable_if<I < sizeof...(Ts), int>::type
 deserialize_tuple(MsgPack::Unpacker& unpacker, std::tuple<Ts...>& out) {
-    if (!deserialize_single(unpacker, std::get<I>(out))) return false;
+    const int res = deserialize_single(unpacker, std::get<I>(out));
+    if (res==TYPE_ERROR) return TYPE_ERROR-I;
     return deserialize_tuple<I + 1>(unpacker, out);
 }
 
 // Helper to invoke a function with a tuple of arguments
 template<typename F, typename Tuple, std::size_t... I>
-inline auto invoke_with_tuple(F&& f, Tuple&& t, arx::stdx::index_sequence<I...>)
+auto invoke_with_tuple(F&& f, Tuple&& t, arx::stdx::index_sequence<I...>)
     -> decltype(f(std::get<I>(std::forward<Tuple>(t))...)) {
     return f(std::get<I>(std::forward<Tuple>(t))...);
 }

src/wrapper.h

@@ -12,6 +12,8 @@
 #ifndef RPCLITE_WRAPPER_H
 #define RPCLITE_WRAPPER_H
 
+#include <string>
+
 #include "error.h"
 #include "rpclite_utils.h"
 
@@ -69,7 +71,20 @@ class RpcFunctionWrapper<std::function<R(Args...)>>: public IFunctionWrapper {
             return false;
         }
 
-        return handle_call(unpacker, packer);
+        const int res = handle_call(unpacker, packer);
+        if (res<0) {
+            MsgPack::str_t err_msg = "Wrong type parameter in position: ";
+#ifdef ARDUINO
+            err_msg += String(TYPE_ERROR-res);
+#else
+            err_msg += std::to_string(TYPE_ERROR-res);
+#endif
+            RpcError error(MALFORMED_CALL_ERR, err_msg);
+            packer.serialize(error, nil);
+            return false;
+        }
+
+        return true;
 
 #ifdef HANDLE_RPC_ERRORS
     } catch (const std::exception& e) {
@@ -86,27 +101,29 @@ class RpcFunctionWrapper<std::function<R(Args...)>>: public IFunctionWrapper {
     std::function<R(Args...)> _func;
 
     template<typename Dummy = R>
-    typename std::enable_if<std::is_void<Dummy>::value, bool>::type
+    typename std::enable_if<std::is_void<Dummy>::value, int>::type
     handle_call(MsgPack::Unpacker& unpacker, MsgPack::Packer& packer) {
         //unpacker not ready if deserialization fails at this point
         std::tuple<Args...> args;
-        if (!deserialize_tuple(unpacker, args)) return false;
+        const int res = deserialize_tuple(unpacker, args);
+        if (res<0) return res;
         MsgPack::object::nil_t nil;
         invoke_with_tuple(_func, args, arx::stdx::make_index_sequence<sizeof...(Args)>{});
         packer.serialize(nil, nil);
-        return true;
+        return 0;
     }
 
     template<typename Dummy = R>
-    typename std::enable_if<!std::is_void<Dummy>::value, bool>::type
+    typename std::enable_if<!std::is_void<Dummy>::value, int>::type
     handle_call(MsgPack::Unpacker& unpacker, MsgPack::Packer& packer) {
         //unpacker not ready if deserialization fails at this point
         std::tuple<Args...> args;
-        if (!deserialize_tuple(unpacker, args)) return false;
+        const int res = deserialize_tuple(unpacker, args);
+        if (res<0) return res;
         MsgPack::object::nil_t nil;
         R out = invoke_with_tuple(_func, args, arx::stdx::make_index_sequence<sizeof...(Args)>{});
         packer.serialize(nil, out);
-        return true;
+        return 0;
     }
 };