Begin adopting std::tuple for IPC decoding
authorandersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 24 Sep 2013 18:16:34 +0000 (18:16 +0000)
committerandersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 24 Sep 2013 18:16:34 +0000 (18:16 +0000)
https://bugs.webkit.org/show_bug.cgi?id=121848

Reviewed by Sam Weinig.

This is the first step towards getting rid of the horrible Arguments class hierarchy.

* Platform/CoreIPC/Arguments.h:
(CoreIPC::TupleCoder::encode):
(CoreIPC::TupleCoder::decode):
* Platform/CoreIPC/HandleMessage.h:
(CoreIPC::callMemberFunction):
(CoreIPC::handleMessage):
(CoreIPC::handleMessageVariadic):
(CoreIPC::handleMessageDelayed):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@156341 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebKit2/ChangeLog
Source/WebKit2/Platform/CoreIPC/Arguments.h
Source/WebKit2/Platform/CoreIPC/HandleMessage.h

index 11ab2c1..5fd6b38 100644 (file)
@@ -1,3 +1,21 @@
+2013-09-24  Anders Carlsson  <andersca@apple.com>
+
+        Begin adopting std::tuple for IPC decoding
+        https://bugs.webkit.org/show_bug.cgi?id=121848
+
+        Reviewed by Sam Weinig.
+
+        This is the first step towards getting rid of the horrible Arguments class hierarchy.
+
+        * Platform/CoreIPC/Arguments.h:
+        (CoreIPC::TupleCoder::encode):
+        (CoreIPC::TupleCoder::decode):
+        * Platform/CoreIPC/HandleMessage.h:
+        (CoreIPC::callMemberFunction):
+        (CoreIPC::handleMessage):
+        (CoreIPC::handleMessageVariadic):
+        (CoreIPC::handleMessageDelayed):
+
 2013-09-24  ChangSeok Oh  <changseok.oh@collabora.com>
 
         [EFL] Build failed at ProcessLauncherEfl.cpp
index 7826074..fa94021 100644 (file)
 #include "ArgumentEncoder.h"
 
 namespace CoreIPC {
-    
+
+template<size_t index, typename... Elements>
+struct TupleCoder {
+    static void encode(ArgumentEncoder& encoder, const std::tuple<Elements...>& tuple)
+    {
+        encoder << std::get<sizeof...(Elements) - index>(tuple);
+        TupleCoder<index - 1, Elements...>::encode(encoder, tuple);
+    }
+
+    static bool decode(ArgumentDecoder& decoder, std::tuple<Elements...>& tuple)
+    {
+        if (!decoder.decode(std::get<sizeof...(Elements) - index>(tuple)))
+            return false;
+        return TupleCoder<index - 1, Elements...>::decode(decoder, tuple);
+    }
+};
+
+template<typename... Elements>
+struct TupleCoder<0, Elements...> {
+    static void encode(ArgumentEncoder& encoder, const std::tuple<Elements...>& tuple)
+    {
+    }
+
+    static bool decode(ArgumentDecoder& decoder, std::tuple<Elements...>& tuple)
+    {
+        return true;
+    }
+};
+
+template<typename... Elements> struct ArgumentCoder<std::tuple<Elements...>> {
+    static void encode(ArgumentEncoder& encoder, const std::tuple<Elements...>& tuple)
+    {
+        TupleCoder<sizeof...(Elements), Elements...>::encode(encoder, tuple);
+    }
+
+    static bool decode(ArgumentDecoder& decoder, std::tuple<Elements...>& tuple)
+    {
+        return TupleCoder<sizeof...(Elements), Elements...>::decode(decoder, tuple);
+    }
+};
+
 struct Arguments0 {
-    typedef Arguments0 ValueType;
+    typedef std::tuple<> ValueType;
 
     void encode(ArgumentEncoder&) const 
     {
@@ -45,7 +85,7 @@ struct Arguments0 {
 };
 
 template<typename T1> struct Arguments1 {
-    typedef Arguments1<typename std::remove_const<typename std::remove_reference<T1>::type>::type> ValueType;
+    typedef std::tuple<typename std::remove_const<typename std::remove_reference<T1>::type>::type> ValueType;
 
     Arguments1()
     {
@@ -70,7 +110,7 @@ template<typename T1> struct Arguments1 {
 };
     
 template<typename T1, typename T2> struct Arguments2 : Arguments1<T1> {
-    typedef Arguments2<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
+    typedef std::tuple<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T2>::type>::type> ValueType;
 
     Arguments2() 
@@ -101,7 +141,7 @@ template<typename T1, typename T2> struct Arguments2 : Arguments1<T1> {
 };
 
 template<typename T1, typename T2, typename T3> struct Arguments3 : Arguments2<T1, T2> {
-    typedef Arguments3<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
+    typedef std::tuple<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T2>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T3>::type>::type> ValueType;
 
@@ -133,7 +173,7 @@ template<typename T1, typename T2, typename T3> struct Arguments3 : Arguments2<T
 };
 
 template<typename T1, typename T2, typename T3, typename T4> struct Arguments4 : Arguments3<T1, T2, T3> {
-    typedef Arguments4<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
+    typedef std::tuple<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T2>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T3>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T4>::type>::type> ValueType;
@@ -166,7 +206,7 @@ template<typename T1, typename T2, typename T3, typename T4> struct Arguments4 :
 };
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5> struct Arguments5 : Arguments4<T1, T2, T3, T4> {
-    typedef Arguments5<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
+    typedef std::tuple<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T2>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T3>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T4>::type>::type,
@@ -200,7 +240,7 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5> struct
 };
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> struct Arguments6 : Arguments5<T1, T2, T3, T4, T5> {
-    typedef Arguments6<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
+    typedef std::tuple<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T2>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T3>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T4>::type>::type,
@@ -235,7 +275,7 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5, typena
 };
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> struct Arguments7 : Arguments6<T1, T2, T3, T4, T5, T6> {
-    typedef Arguments7<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
+    typedef std::tuple<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T2>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T3>::type>::type,
                        typename std::remove_const<typename std::remove_reference<T4>::type>::type,
@@ -271,7 +311,7 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5, typena
 };
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> struct Arguments8 : Arguments7<T1, T2, T3, T4, T5, T6, T7> {
-    typedef Arguments8<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
+    typedef std::tuple<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
     typename std::remove_const<typename std::remove_reference<T2>::type>::type,
     typename std::remove_const<typename std::remove_reference<T3>::type>::type,
     typename std::remove_const<typename std::remove_reference<T4>::type>::type,
@@ -306,7 +346,7 @@ template<typename T1, typename T2, typename T3, typename T4, typename T5, typena
 };
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> struct Arguments10 : Arguments8<T1, T2, T3, T4, T5, T6, T7, T8> {
-    typedef Arguments10<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
+    typedef std::tuple<typename std::remove_const<typename std::remove_reference<T1>::type>::type,
     typename std::remove_const<typename std::remove_reference<T2>::type>::type,
     typename std::remove_const<typename std::remove_reference<T3>::type>::type,
     typename std::remove_const<typename std::remove_reference<T4>::type>::type,
index 06a1d34..73d67bc 100644 (file)
 namespace CoreIPC {
 
 // Dispatch functions with no reply arguments.
-
 template<typename C, typename MF>
-void callMemberFunction(const Arguments0&, C* object, MF function)
+void callMemberFunction(std::tuple<>&&, C* object, MF function)
 {
     (object->*function)();
 }
 
 template<typename C, typename MF, typename P1>
-void callMemberFunction(const Arguments1<P1>& args, C* object, MF function)
+void callMemberFunction(std::tuple<P1>&& args, C* object, MF function)
 {
-    (object->*function)(args.argument1);
+    (object->*function)(std::get<0>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2>
-void callMemberFunction(const Arguments2<P1, P2>& args, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2>&& args, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2);
+    (object->*function)(std::get<0>(args), std::get<1>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3>
-void callMemberFunction(const Arguments3<P1, P2, P3>& args, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3>&& args, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4>
-void callMemberFunction(const Arguments4<P1, P2, P3, P4>& args, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4>&& args, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5>
-void callMemberFunction(const Arguments5<P1, P2, P3, P4, P5>& args, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5>&& args, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args));
 }
     
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-void callMemberFunction(const Arguments6<P1, P2, P3, P4, P5, P6>& args, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6>&& args, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-void callMemberFunction(const Arguments7<P1, P2, P3, P4, P5, P6, P7>& args, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6, P7>&& args, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, args.argument7);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<6>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-void callMemberFunction(const Arguments8<P1, P2, P3, P4, P5, P6, P7, P8>& args, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6, P7, P8>&& args, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, args.argument7, args.argument8);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<6>(args), std::get<7>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
-void callMemberFunction(const Arguments10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>& args, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>&& args, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, args.argument7, args.argument8, args.argument9, args.argument10);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<6>(args), std::get<7>(args), std::get<8>(args), std::get<9>(args));
 }
 
 // Dispatch functions with reply arguments.
 
 template<typename C, typename MF>
-void callMemberFunction(const Arguments0&, Arguments0&, C* object, MF function)
+void callMemberFunction(std::tuple<>&&, std::tuple<>&, C* object, MF function)
 {
     (object->*function)();
 }
 
 template<typename C, typename MF, typename R1>
-void callMemberFunction(const Arguments0&, Arguments1<R1>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<>&&, std::tuple<R1>& replyArgs, C* object, MF function)
 {
-    (object->*function)(replyArgs.argument1);
+    (object->*function)(std::get<0>(replyArgs));
 }
 
 template<typename C, typename MF, typename R1, typename R2>
-void callMemberFunction(const Arguments0&, Arguments2<R1, R2>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<>&&, std::tuple<R1, R2>& replyArgs, C* object, MF function)
 {
-    (object->*function)(replyArgs.argument1, replyArgs.argument2);
+    (object->*function)(std::get<0>(replyArgs), std::get<1>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1>
-void callMemberFunction(const Arguments1<P1>& args, Arguments0&, C* object, MF function)
+void callMemberFunction(std::tuple<P1>&& args, std::tuple<>&, C* object, MF function)
 {
-    (object->*function)(args.argument1);
+    (object->*function)(std::get<0>(args));
 }
 
 template<typename C, typename MF, typename P1, typename R1>
-void callMemberFunction(const Arguments1<P1>& args, Arguments1<R1>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1>&& args, std::tuple<R1>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, replyArgs.argument1);
+    (object->*function)(std::get<0>(args), std::get<0>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename R1, typename R2>
-void callMemberFunction(const Arguments1<P1>& args, Arguments2<R1, R2>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1>&& args, std::tuple<R1, R2>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, replyArgs.argument1, replyArgs.argument2);
+    (object->*function)(std::get<0>(args), std::get<0>(replyArgs), std::get<1>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename R1, typename R2, typename R3>
-void callMemberFunction(const Arguments1<P1>& args, Arguments3<R1, R2, R3>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1>&& args, std::tuple<R1, R2, R3>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, replyArgs.argument1, replyArgs.argument2, replyArgs.argument3);
+    (object->*function)(std::get<0>(args), std::get<0>(replyArgs), std::get<1>(replyArgs), std::get<2>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2>
-void callMemberFunction(const Arguments2<P1, P2>& args, Arguments0&, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2>&& args, std::tuple<>&, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2);
+    (object->*function)(std::get<0>(args), std::get<1>(args));
 }
 
 template<typename C, typename MF, typename P1, typename R1, typename R2, typename R3, typename R4>
-void callMemberFunction(const Arguments1<P1>& args, Arguments4<R1, R2, R3, R4>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1>&& args, Arguments4<R1, R2, R3, R4>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, replyArgs.argument1, replyArgs.argument2, replyArgs.argument3, replyArgs.argument4);
+    (object->*function)(std::get<0>(args), std::get<0>(replyArgs), std::get<1>(replyArgs), std::get<2>(replyArgs), std::get<3>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename R1>
-void callMemberFunction(const Arguments2<P1, P2>& args, Arguments1<R1>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2>&& args, std::tuple<R1>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, replyArgs.argument1);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<0>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename R1, typename R2>
-void callMemberFunction(const Arguments2<P1, P2>& args, Arguments2<R1, R2>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2>&& args, std::tuple<R1, R2>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, replyArgs.argument1, replyArgs.argument2);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<0>(replyArgs), std::get<1>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename R1>
-void callMemberFunction(const Arguments3<P1, P2, P3>& args, Arguments1<R1>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3>&& args, std::tuple<R1>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, replyArgs.argument1);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<0>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename R1, typename R2>
-void callMemberFunction(const Arguments3<P1, P2, P3>& args, Arguments2<R1, R2>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3>&& args, std::tuple<R1, R2>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, replyArgs.argument1, replyArgs.argument2);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<0>(replyArgs), std::get<1>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename R1>
-void callMemberFunction(const Arguments4<P1, P2, P3, P4>& args, Arguments1<R1>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4>&& args, std::tuple<R1>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, replyArgs.argument1);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<0>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename R1>
-void callMemberFunction(const Arguments6<P1, P2, P3, P4, P5, P6>& args, Arguments1<R1>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6>&& args, std::tuple<R1>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, replyArgs.argument1);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<0>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename R1>
-void callMemberFunction(const Arguments7<P1, P2, P3, P4, P5, P6, P7>& args, Arguments1<R1>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6, P7>&& args, std::tuple<R1>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, args.argument7, replyArgs.argument1);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<6>(args), std::get<0>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename R1>
-void callMemberFunction(const Arguments8<P1, P2, P3, P4, P5, P6, P7, P8>& args, Arguments1<R1>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6, P7, P8>&& args, std::tuple<R1>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, args.argument7, args.argument8, replyArgs.argument1);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<6>(args), std::get<7>(args), std::get<0>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename R1, typename R2>
-void callMemberFunction(const Arguments4<P1, P2, P3, P4>& args, Arguments2<R1, R2>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4>&& args, std::tuple<R1, R2>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, replyArgs.argument1, replyArgs.argument2);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<0>(replyArgs), std::get<1>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename R1, typename R2>
-void callMemberFunction(const Arguments5<P1, P2, P3, P4, P5>& args, Arguments2<R1, R2>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5>&& args, std::tuple<R1, R2>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, replyArgs.argument1, replyArgs.argument2);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<0>(replyArgs), std::get<1>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename R1, typename R2, typename R3>
-void callMemberFunction(const Arguments4<P1, P2, P3, P4>& args, Arguments3<R1, R2, R3>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4>&& args, std::tuple<R1, R2, R3>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, replyArgs.argument1, replyArgs.argument2, replyArgs.argument3);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<0>(replyArgs), std::get<1>(replyArgs), std::get<2>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename R1, typename R2, typename R3>
-void callMemberFunction(const Arguments5<P1, P2, P3, P4, P5>& args, Arguments3<R1, R2, R3>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5>&& args, std::tuple<R1, R2, R3>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, replyArgs.argument1, replyArgs.argument2, replyArgs.argument3);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<0>(replyArgs), std::get<1>(replyArgs), std::get<2>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename R1, typename R2>
-void callMemberFunction(const Arguments6<P1, P2, P3, P4, P5, P6>& args, Arguments2<R1, R2>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6>&& args, std::tuple<R1, R2>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, replyArgs.argument1, replyArgs.argument2);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<0>(replyArgs), std::get<1>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename R1, typename R2, typename R3>
-void callMemberFunction(const Arguments6<P1, P2, P3, P4, P5, P6>& args, Arguments3<R1, R2, R3>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6>&& args, std::tuple<R1, R2, R3>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, replyArgs.argument1, replyArgs.argument2, replyArgs.argument3);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<0>(replyArgs), std::get<1>(replyArgs), std::get<2>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename R1, typename R2, typename R3, typename R4>
-void callMemberFunction(const Arguments6<P1, P2, P3, P4, P5, P6>& args, Arguments4<R1, R2, R3, R4>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6>&& args, std::tuple<R1, R2, R3, R4>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, replyArgs.argument1, replyArgs.argument2, replyArgs.argument3, replyArgs.argument4);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<0>(replyArgs), std::get<1>(replyArgs), std::get<2>(replyArgs), std::get<3>(replyArgs));
 }
 
 // Dispatch functions with delayed reply arguments.
 template<typename C, typename MF, typename R>
-void callMemberFunction(const Arguments0&, PassRefPtr<R> delayedReply, C* object, MF function)
+void callMemberFunction(std::tuple<>&&, PassRefPtr<R> delayedReply, C* object, MF function)
 {
     (object->*function)(delayedReply);
 }
 
 template<typename C, typename MF, typename P1, typename R>
-void callMemberFunction(const Arguments1<P1>& args, PassRefPtr<R> delayedReply, C* object, MF function)
+void callMemberFunction(std::tuple<P1>&& args, PassRefPtr<R> delayedReply, C* object, MF function)
 {
-    (object->*function)(args.argument1, delayedReply);
+    (object->*function)(std::get<0>(args), delayedReply);
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename R>
-void callMemberFunction(const Arguments2<P1, P2>& args, PassRefPtr<R> delayedReply, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2>&& args, PassRefPtr<R> delayedReply, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, delayedReply);
+    (object->*function)(std::get<0>(args), std::get<1>(args), delayedReply);
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename R>
-void callMemberFunction(const Arguments8<P1, P2, P3, P4, P5, P6, P7, P8>& args, PassRefPtr<R> delayedReply, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6, P7, P8>&& args, PassRefPtr<R> delayedReply, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, args.argument7, args.argument8, delayedReply);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<6>(args), std::get<7>(args), delayedReply);
 }
 
 // Dispatch functions with connection parameter.
 template<typename C, typename MF>
-void callMemberFunction(Connection* connection, const Arguments0&, C* object, MF function)
+void callMemberFunction(Connection* connection, std::tuple<>&&, C* object, MF function)
 {
     (object->*function)(connection);
 }
 
 template<typename C, typename MF, typename P1>
-void callMemberFunction(Connection* connection, const Arguments1<P1>& args, C* object, MF function)
+void callMemberFunction(Connection* connection, std::tuple<P1>&& args, C* object, MF function)
 {
-    (object->*function)(connection, args.argument1);
+    (object->*function)(connection, std::get<0>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2>
-void callMemberFunction(Connection* connection, const Arguments2<P1, P2>& args, C* object, MF function)
+void callMemberFunction(Connection* connection, std::tuple<P1, P2>&& args, C* object, MF function)
 {
-    (object->*function)(connection, args.argument1, args.argument2);
+    (object->*function)(connection, std::get<0>(args), std::get<1>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3>
-void callMemberFunction(Connection* connection, const Arguments3<P1, P2, P3>& args, C* object, MF function)
+void callMemberFunction(Connection* connection, std::tuple<P1, P2, P3>&& args, C* object, MF function)
 {
-    (object->*function)(connection, args.argument1, args.argument2, args.argument3);
+    (object->*function)(connection, std::get<0>(args), std::get<1>(args), std::get<2>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4>
-void callMemberFunction(Connection* connection, const Arguments4<P1, P2, P3, P4>& args, C* object, MF function)
+void callMemberFunction(Connection* connection, std::tuple<P1, P2, P3, P4>&& args, C* object, MF function)
 {
-    (object->*function)(connection, args.argument1, args.argument2, args.argument3, args.argument4);
+    (object->*function)(connection, std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5>
-void callMemberFunction(Connection* connection, const Arguments5<P1, P2, P3, P4, P5>& args, C* object, MF function)
+void callMemberFunction(Connection* connection, std::tuple<P1, P2, P3, P4, P5>&& args, C* object, MF function)
 {
-    (object->*function)(connection, args.argument1, args.argument2, args.argument3, args.argument4, args.argument5);
+    (object->*function)(connection, std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-void callMemberFunction(Connection* connection, const Arguments6<P1, P2, P3, P4, P5, P6>& args, C* object, MF function)
+void callMemberFunction(Connection* connection, std::tuple<P1, P2, P3, P4, P5, P6>&& args, C* object, MF function)
 {
-    (object->*function)(connection, args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6);
+    (object->*function)(connection, std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename R1>
-void callMemberFunction(Connection* connection, const Arguments2<P1, P2>& args, Arguments1<R1>& replyArgs, C* object, MF function)
+void callMemberFunction(Connection* connection, std::tuple<P1, P2>&& args, std::tuple<R1>& replyArgs, C* object, MF function)
 {
-    (object->*function)(connection, args.argument1, args.argument2, replyArgs.argument1);
+    (object->*function)(connection, std::get<0>(args), std::get<1>(args), std::get<0>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename R1>
-void callMemberFunction(Connection* connection, const Arguments1<P1>& args, Arguments1<R1>& replyArgs, C* object, MF function)
+void callMemberFunction(Connection* connection, std::tuple<P1>&& args, std::tuple<R1>& replyArgs, C* object, MF function)
 {
-    (object->*function)(connection, args.argument1, replyArgs.argument1);
+    (object->*function)(connection, std::get<0>(args), std::get<0>(replyArgs));
 }
 
 // Variadic dispatch functions.
 
 template<typename C, typename MF>
-void callMemberFunction(const Arguments0&, MessageDecoder& decoder, C* object, MF function)
+void callMemberFunction(std::tuple<>&&, MessageDecoder& decoder, C* object, MF function)
 {
     (object->*function)(decoder);
 }
 
 template<typename C, typename MF, typename P1>
-void callMemberFunction(const Arguments1<P1>& args, MessageDecoder& decoder, C* object, MF function)
+void callMemberFunction(std::tuple<P1>&& args, MessageDecoder& decoder, C* object, MF function)
 {
-    (object->*function)(args.argument1, decoder);
+    (object->*function)(std::get<0>(args), decoder);
 }
 
 template<typename C, typename MF, typename P1, typename P2>
-void callMemberFunction(const Arguments2<P1, P2>& args, MessageDecoder& decoder, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2>&& args, MessageDecoder& decoder, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, decoder);
+    (object->*function)(std::get<0>(args), std::get<1>(args), decoder);
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3>
-void callMemberFunction(const Arguments3<P1, P2, P3>& args, MessageDecoder& decoder, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3>&& args, MessageDecoder& decoder, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, decoder);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), decoder);
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4>
-void callMemberFunction(const Arguments4<P1, P2, P3, P4>& args, MessageDecoder& decoder, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4>&& args, MessageDecoder& decoder, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, decoder);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), decoder);
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5>
-void callMemberFunction(const Arguments5<P1, P2, P3, P4, P5>& args, MessageDecoder& decoder, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5>&& args, MessageDecoder& decoder, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, decoder);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), decoder);
 }
     
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-void callMemberFunction(const Arguments6<P1, P2, P3, P4, P5, P6>& args, MessageDecoder& decoder, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6>&& args, MessageDecoder& decoder, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, decoder);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), decoder);
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-void callMemberFunction(const Arguments7<P1, P2, P3, P4, P5, P6, P7>& args, MessageDecoder& decoder, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6, P7>&& args, MessageDecoder& decoder, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, args.argument7, decoder);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), std::get<6>(args), decoder);
 }
 
 // Variadic dispatch functions with non-variadic reply arguments.
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename R1, typename R2, typename R3>
-void callMemberFunction(const Arguments4<P1, P2, P3, P4>& args, MessageDecoder& decoder, Arguments3<R1, R2, R3>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4>&& args, MessageDecoder& decoder, std::tuple<R1, R2, R3>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, decoder, replyArgs.argument1, replyArgs.argument2, replyArgs.argument3);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), decoder, std::get<0>(replyArgs), std::get<1>(replyArgs), std::get<2>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename R1, typename R2>
-void callMemberFunction(const Arguments6<P1, P2, P3, P4, P5, P6>& args, MessageDecoder& decoder, Arguments2<R1, R2>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6>&& args, MessageDecoder& decoder, std::tuple<R1, R2>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, decoder, replyArgs.argument1, replyArgs.argument2);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), decoder, std::get<0>(replyArgs), std::get<1>(replyArgs));
 }
 
 template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename R1, typename R2, typename R3>
-void callMemberFunction(const Arguments6<P1, P2, P3, P4, P5, P6>& args, MessageDecoder& decoder, Arguments3<R1, R2, R3>& replyArgs, C* object, MF function)
+void callMemberFunction(std::tuple<P1, P2, P3, P4, P5, P6>&& args, MessageDecoder& decoder, std::tuple<R1, R2, R3>& replyArgs, C* object, MF function)
 {
-    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, decoder, replyArgs.argument1, replyArgs.argument2, replyArgs.argument3);
+    (object->*function)(std::get<0>(args), std::get<1>(args), std::get<2>(args), std::get<3>(args), std::get<4>(args), std::get<5>(args), decoder, std::get<0>(replyArgs), std::get<1>(replyArgs), std::get<2>(replyArgs));
 }
 
 // Main dispatch functions
@@ -373,7 +372,7 @@ void handleMessage(MessageDecoder& decoder, C* object, MF function)
     typename T::DecodeType::ValueType arguments;
     if (!decoder.decode(arguments))
         return;
-    callMemberFunction(arguments, object, function);
+    callMemberFunction(std::move(arguments), object, function);
 }
 
 template<typename T, typename C, typename MF>
@@ -384,7 +383,7 @@ void handleMessage(MessageDecoder& decoder, MessageEncoder& replyEncoder, C* obj
         return;
 
     typename T::Reply::ValueType replyArguments;
-    callMemberFunction(arguments, replyArguments, object, function);
+    callMemberFunction(std::move(arguments), replyArguments, object, function);
     replyEncoder << replyArguments;
 }
 
@@ -396,7 +395,7 @@ void handleMessage(Connection* connection, MessageDecoder& decoder, MessageEncod
         return;
 
     typename T::Reply::ValueType replyArguments;
-    callMemberFunction(connection, arguments, replyArguments, object, function);
+    callMemberFunction(connection, std::move(arguments), replyArguments, object, function);
     replyEncoder << replyArguments;
 }
 
@@ -406,7 +405,7 @@ void handleMessage(Connection* connection, MessageDecoder& decoder, C* object, M
     typename T::DecodeType::ValueType arguments;
     if (!decoder.decode(arguments))
         return;
-    callMemberFunction(connection, arguments, object, function);
+    callMemberFunction(connection, std::move(arguments), object, function);
 }
 
 template<typename T, typename C, typename MF>
@@ -415,7 +414,7 @@ void handleMessageVariadic(MessageDecoder& decoder, C* object, MF function)
     typename T::DecodeType::ValueType arguments;
     if (!decoder.decode(arguments))
         return;
-    callMemberFunction(arguments, decoder, object, function);
+    callMemberFunction(std::move(arguments), decoder, object, function);
 }
 
 template<typename T, typename C, typename MF>
@@ -426,7 +425,7 @@ void handleMessageVariadic(MessageDecoder& decoder, MessageEncoder& replyEncoder
         return;
 
     typename T::Reply::ValueType replyArguments;
-    callMemberFunction(arguments, decoder, replyArguments, object, function);
+    callMemberFunction(std::move(arguments), decoder, replyArguments, object, function);
     replyEncoder << replyArguments;
 }
 
@@ -438,7 +437,7 @@ void handleMessageDelayed(Connection* connection, MessageDecoder& decoder, OwnPt
         return;
 
     RefPtr<typename T::DelayedReply> delayedReply = adoptRef(new typename T::DelayedReply(connection, replyEncoder.release()));
-    callMemberFunction(arguments, delayedReply.release(), object, function);
+    callMemberFunction(std::move(arguments), delayedReply.release(), object, function);
 }
 
 } // namespace CoreIPC