mod: reverted rpclite_utils

Author: eigen-value

src/decoder.h

@@ -4,7 +4,6 @@
 #include "MsgPack.h"
 #include "transport.h"
 #include "dispatcher.h"
-#include "rpclite_utils.h"
 
 
 #define NO_MSG          -1
@@ -294,6 +293,91 @@ class RpcDecoder {
         return 0;
     }
 
+    bool unpackArray(MsgPack::Unpacker& unpacker, size_t& size) {
+        MsgPack::arr_size_t sz;
+        unpacker.deserialize(sz);
+
+        size = 0;
+        for (size_t i=0; i<sz.size(); i++){
+            if (unpackObject(unpacker)){
+                size++;
+            } else {
+                return false;
+            }
+        }
+
+        return true;
+
+    }
+
+    bool unpackMap(MsgPack::Unpacker& unpacker, size_t& size) {
+        MsgPack::map_size_t sz;
+        unpacker.deserialize(sz);
+
+        size = 0;
+        for (size_t i=0; i<sz.size(); i++){
+            if (unpackObject(unpacker) && unpackObject(unpacker)){  // must unpack key&value
+                size++;
+            } else {
+                return false;
+            }
+        }
+
+        return true;
+
+    }
+
+    bool unpackObject(MsgPack::Unpacker& unpacker){
+
+        if (unpacker.isNil()){
+            static MsgPack::object::nil_t nil;
+            return unpacker.deserialize(nil);
+        }
+        if (unpacker.isBool()){
+            static bool b;
+            return unpacker.deserialize(b);
+        }
+        if (unpacker.isUInt() || unpacker.isInt()){
+            static int integer;
+            return unpacker.deserialize(integer);
+        }
+        if (unpacker.isFloat32()){
+            static float num32;
+            return unpacker.deserialize(num32);
+        }
+        if (unpacker.isFloat64()){
+            static double num64;
+            return unpacker.deserialize(num64);
+        }
+        if (unpacker.isStr()){
+            static MsgPack::str_t string;
+            return unpacker.deserialize(string);
+        }
+        if (unpacker.isBin()){
+            static MsgPack::bin_t<uint8_t> bytes;
+            return unpacker.deserialize(bytes);
+        }
+        if (unpacker.isArray()){
+            static size_t arr_sz;
+            return unpackArray(unpacker, arr_sz);
+        }
+        if (unpacker.isMap()){
+            static size_t map_sz;
+            return unpackMap(unpacker, map_sz);
+        }
+        if (unpacker.isFixExt() || unpacker.isExt()){
+            static MsgPack::object::ext e;
+            return unpacker.deserialize(e);
+        }
+        if (unpacker.isTimestamp()){
+            static MsgPack::object::timespec t;
+            return unpacker.deserialize(t);
+        }
+
+        return false;
+    }
+
+
 };
 
 #endif

src/rpclite_utils.h

@@ -2,14 +2,50 @@
 #define RPCLITE_WRAPPER_H
 
 #include "error.h"
-#include "rpclite_utils.h"
 
-using namespace RpcUtils::detail;
 
 #ifdef HANDLE_RPC_ERRORS
 #include <stdexcept>
 #endif
 
+template<typename T>
+bool deserialize_single(MsgPack::Unpacker& unpacker, T& value) {
+    if (!unpacker.unpackable(value)) return false;
+    unpacker.deserialize(value);
+    return true;
+}
+
+
+/////////////////////////////
+/// --- tuple helpers --- ///
+/////////////////////////////
+
+template<std::size_t I = 0, typename... Ts>
+typename std::enable_if<I == sizeof...(Ts), bool>::type
+deserialize_tuple(MsgPack::Unpacker&, std::tuple<Ts...>&) {
+    return true;
+}
+
+template<std::size_t I = 0, typename... Ts>
+typename std::enable_if<I < sizeof...(Ts), bool>::type
+deserialize_tuple(MsgPack::Unpacker& unpacker, std::tuple<Ts...>& out) {
+    if (!deserialize_single(unpacker, std::get<I>(out))) return false;
+    return deserialize_tuple<I + 1>(unpacker, out);
+}
+
+template<typename... Ts>
+bool deserialize_all(MsgPack::Unpacker& unpacker, std::tuple<Ts...>& values) {
+    return deserialize_tuple(unpacker, values);
+}
+
+// Helper to invoke a function with a tuple of arguments
+template<typename F, typename Tuple, std::size_t... 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))...);
+}
+
+
 template<typename F>
 class RpcFunctionWrapper;