OLD | NEW |
1 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // This header is meant to be included in multiple passes, hence no traditional | 5 // This header is meant to be included in multiple passes, hence no traditional |
6 // header guard. | 6 // header guard. |
7 // | 7 // |
8 // In the first pass, IPC_MESSAGE_MACROS_ENUMS should be defined, which will | 8 // In the first pass, IPC_MESSAGE_MACROS_ENUMS should be defined, which will |
9 // create enums for each of the messages defined with the IPC_MESSAGE_* macros. | 9 // create enums for each of the messages defined with the IPC_MESSAGE_* macros. |
10 // | 10 // |
(...skipping 827 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
838 public: \ | 838 public: \ |
839 enum { ID = msg_class##__ID }; \ | 839 enum { ID = msg_class##__ID }; \ |
840 msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \ | 840 msg_class(int32 routing_id, const type1& arg1, const type2& arg2, \ |
841 const type3& arg3, const type4& arg4, const type5& arg5); \ | 841 const type3& arg3, const type4& arg4, const type5& arg5); \ |
842 ~msg_class(); \ | 842 ~msg_class(); \ |
843 static void Log(const Message* msg, std::wstring* l); \ | 843 static void Log(const Message* msg, std::wstring* l); \ |
844 }; | 844 }; |
845 | 845 |
846 #define IPC_SYNC_MESSAGE_CONTROL0_0(msg_class) \ | 846 #define IPC_SYNC_MESSAGE_CONTROL0_0(msg_class) \ |
847 class msg_class : public IPC::MessageWithReply<Tuple0, Tuple0 > { \ | 847 class msg_class : public IPC::MessageWithReply<Tuple0, Tuple0 > { \ |
848 public: \ | 848 public: \ |
849 enum { ID = msg_class##__ID }; \ | 849 enum { ID = msg_class##__ID }; \ |
850 msg_class(); \ | 850 msg_class() \ |
851 ~msg_class(); \ | 851 : IPC::MessageWithReply<Tuple0, Tuple0 >( \ |
852 static void Log(const Message* msg, std::wstring* l); \ | 852 MSG_ROUTING_CONTROL, ID, \ |
| 853 MakeTuple(), MakeTuple()) {} \ |
853 }; | 854 }; |
854 | 855 |
855 #define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out) \ | 856 #define IPC_SYNC_MESSAGE_CONTROL0_1(msg_class, type1_out) \ |
856 class msg_class : public IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> > {
\ | 857 class msg_class : public IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> > {
\ |
857 public: \ | 858 public: \ |
858 enum { ID = msg_class##__ID }; \ | 859 enum { ID = msg_class##__ID }; \ |
859 msg_class(type1_out* arg1); \ | 860 msg_class(type1_out* arg1) \ |
860 ~msg_class(); \ | 861 : IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> >( \ |
861 static void Log(const Message* msg, std::wstring* l); \ | 862 MSG_ROUTING_CONTROL, \ |
| 863 ID, \ |
| 864 MakeTuple(), MakeRefTuple(*arg1)) {} \ |
862 }; | 865 }; |
863 | 866 |
864 #define IPC_SYNC_MESSAGE_CONTROL0_2(msg_class, type1_out, type2_out) \ | 867 #define IPC_SYNC_MESSAGE_CONTROL0_2(msg_class, type1_out, type2_out) \ |
865 class msg_class : \ | 868 class msg_class : \ |
866 public IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> > { \ | 869 public IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> > { \ |
867 public: \ | 870 public: \ |
868 enum { ID = msg_class##__ID }; \ | 871 enum { ID = msg_class##__ID }; \ |
869 msg_class(type1_out* arg1, type2_out* arg2); \ | 872 msg_class(type1_out* arg1, type2_out* arg2) \ |
870 ~msg_class(); \ | 873 : IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> >( \ |
871 static void Log(const Message* msg, std::wstring* l); \ | 874 MSG_ROUTING_CONTROL, \ |
| 875 ID, \ |
| 876 MakeTuple(), MakeRefTuple(*arg1, *arg2)) {} \ |
872 }; | 877 }; |
873 | 878 |
874 #define IPC_SYNC_MESSAGE_CONTROL0_3(msg_class, type1_out, type2_out, type3_out)
\ | 879 #define IPC_SYNC_MESSAGE_CONTROL0_3(msg_class, type1_out, type2_out, type3_out)
\ |
875 class msg_class : \ | 880 class msg_class : \ |
876 public IPC::MessageWithReply<Tuple0, \ | 881 public IPC::MessageWithReply<Tuple0, \ |
877 Tuple3<type1_out&, type2_out&, type3_out&> >{ \ | 882 Tuple3<type1_out&, type2_out&, type3_out&> >{ \ |
878 public: \ | 883 public: \ |
879 enum { ID = msg_class##__ID }; \ | 884 enum { ID = msg_class##__ID }; \ |
880 msg_class(type1_out* arg1, type2_out* arg2, type3_out* arg3); \ | 885 msg_class(type1_out* arg1, type2_out* arg2, type3_out* arg3) \ |
881 ~msg_class(); \ | 886 : IPC::MessageWithReply<Tuple0, \ |
882 static void Log(const Message* msg, std::wstring* l); \ | 887 Tuple3<type1_out&, type2_out&, type3_out&> >(MSG_ROUTING_CONTROL, \ |
| 888 ID, \ |
| 889 MakeTuple(), MakeRefTuple(*arg1, *arg2, *arg3)) {} \ |
883 }; | 890 }; |
884 | 891 |
885 #define IPC_SYNC_MESSAGE_CONTROL1_0(msg_class, type1_in) \ | 892 #define IPC_SYNC_MESSAGE_CONTROL1_0(msg_class, type1_in) \ |
886 class msg_class : \ | 893 class msg_class : \ |
887 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 > { \ | 894 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 > { \ |
888 public: \ | 895 public: \ |
889 enum { ID = msg_class##__ID }; \ | 896 enum { ID = msg_class##__ID }; \ |
890 msg_class(const type1_in& arg1); \ | 897 msg_class(const type1_in& arg1) \ |
891 ~msg_class(); \ | 898 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 >( \ |
892 static void Log(const Message* msg, std::wstring* l); \ | 899 MSG_ROUTING_CONTROL, ID, \ |
| 900 MakeRefTuple(arg1), MakeTuple()) {} \ |
893 }; | 901 }; |
894 | 902 |
895 #define IPC_SYNC_MESSAGE_CONTROL1_1(msg_class, type1_in, type1_out) \ | 903 #define IPC_SYNC_MESSAGE_CONTROL1_1(msg_class, type1_in, type1_out) \ |
896 class msg_class : \ | 904 class msg_class : \ |
897 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> > { \ | 905 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> > { \ |
898 public: \ | 906 public: \ |
899 enum { ID = msg_class##__ID }; \ | 907 enum { ID = msg_class##__ID }; \ |
900 msg_class(const type1_in& arg1, type1_out* arg2); \ | 908 msg_class(const type1_in& arg1, type1_out* arg2) \ |
901 ~msg_class(); \ | 909 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> >( \ |
902 static void Log(const Message* msg, std::wstring* l); \ | 910 MSG_ROUTING_CONTROL, ID, \ |
| 911 MakeRefTuple(arg1), MakeRefTuple(*arg2)) {} \ |
903 }; | 912 }; |
904 | 913 |
905 #define IPC_SYNC_MESSAGE_CONTROL1_2(msg_class, type1_in, type1_out, type2_out) \ | 914 #define IPC_SYNC_MESSAGE_CONTROL1_2(msg_class, type1_in, type1_out, type2_out) \ |
906 class msg_class : \ | 915 class msg_class : \ |
907 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple2<type1_out&, type2_ou
t&> > { \ | 916 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple2<type1_out&, type2_ou
t&> > { \ |
908 public: \ | 917 public: \ |
909 enum { ID = msg_class##__ID }; \ | 918 enum { ID = msg_class##__ID }; \ |
910 msg_class(const type1_in& arg1, type1_out* arg2, type2_out* arg3); \ | 919 msg_class(const type1_in& arg1, type1_out* arg2, type2_out* arg3) \ |
911 ~msg_class(); \ | 920 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple2<type1_out&, type2_out&>
>( \ |
912 static void Log(const Message* msg, std::wstring* l); \ | 921 MSG_ROUTING_CONTROL, ID, \ |
| 922 MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3)) {} \ |
913 }; | 923 }; |
914 | 924 |
915 #define IPC_SYNC_MESSAGE_CONTROL1_3(msg_class, type1_in, type1_out, type2_out, t
ype3_out) \ | 925 #define IPC_SYNC_MESSAGE_CONTROL1_3(msg_class, type1_in, type1_out, type2_out, t
ype3_out) \ |
916 class msg_class : \ | 926 class msg_class : \ |
917 public IPC::MessageWithReply<Tuple1<type1_in>, \ | 927 public IPC::MessageWithReply<Tuple1<type1_in>, \ |
918 Tuple3<type1_out&, type2_out&, type3_out&> >{ \ | 928 Tuple3<type1_out&, type2_out&, type3_out&> >{ \ |
919 public: \ | 929 public: \ |
920 enum { ID = msg_class##__ID }; \ | 930 enum { ID = msg_class##__ID }; \ |
921 msg_class(const type1_in& arg1, type1_out* arg2, type2_out* arg3, type3_out*
arg4); \ | 931 msg_class(const type1_in& arg1, type1_out* arg2, type2_out* arg3, type3_out*
arg4) \ |
922 ~msg_class(); \ | 932 : IPC::MessageWithReply<Tuple1<type1_in>, \ |
923 static void Log(const Message* msg, std::wstring* l); \ | 933 Tuple3<type1_out&, type2_out&, type3_out&> >(MSG_ROUTING_CONTROL, \ |
| 934 ID, \ |
| 935 MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3, *arg4)) {} \ |
924 }; | 936 }; |
925 | 937 |
926 #define IPC_SYNC_MESSAGE_CONTROL2_0(msg_class, type1_in, type2_in) \ | 938 #define IPC_SYNC_MESSAGE_CONTROL2_0(msg_class, type1_in, type2_in) \ |
927 class msg_class : \ | 939 class msg_class : \ |
928 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 > { \ | 940 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 > { \ |
929 public: \ | 941 public: \ |
930 enum { ID = msg_class##__ID }; \ | 942 enum { ID = msg_class##__ID }; \ |
931 msg_class(const type1_in& arg1, const type2_in& arg2); \ | 943 msg_class(const type1_in& arg1, const type2_in& arg2) \ |
932 ~msg_class(); \ | 944 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 >( \ |
933 static void Log(const Message* msg, std::wstring* l); \ | 945 MSG_ROUTING_CONTROL, ID, \ |
| 946 MakeRefTuple(arg1, arg2), MakeTuple()) {} \ |
934 }; | 947 }; |
935 | 948 |
936 #define IPC_SYNC_MESSAGE_CONTROL2_1(msg_class, type1_in, type2_in, type1_out) \ | 949 #define IPC_SYNC_MESSAGE_CONTROL2_1(msg_class, type1_in, type2_in, type1_out) \ |
937 class msg_class : \ | 950 class msg_class : \ |
938 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple1<type1_out&
> > { \ | 951 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple1<type1_out&
> > { \ |
939 public: \ | 952 public: \ |
940 enum { ID = msg_class##__ID }; \ | 953 enum { ID = msg_class##__ID }; \ |
941 msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3); \ | 954 msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3) \ |
942 ~msg_class(); \ | 955 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple1<type1_out&> >
( \ |
943 static void Log(const Message* msg, std::wstring* l); \ | 956 MSG_ROUTING_CONTROL, ID, \ |
| 957 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3)) {} \ |
944 }; | 958 }; |
945 | 959 |
946 #define IPC_SYNC_MESSAGE_CONTROL2_2(msg_class, type1_in, type2_in, type1_out, ty
pe2_out) \ | 960 #define IPC_SYNC_MESSAGE_CONTROL2_2(msg_class, type1_in, type2_in, type1_out, ty
pe2_out) \ |
947 class msg_class : \ | 961 class msg_class : \ |
948 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ | 962 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
949 Tuple2<type1_out&, type2_out&> > { \ | 963 Tuple2<type1_out&, type2_out&> > { \ |
950 public: \ | 964 public: \ |
951 enum { ID = msg_class##__ID }; \ | 965 enum { ID = msg_class##__ID }; \ |
952 msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2_
out* arg4); \ | 966 msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2
_out* arg4) \ |
953 ~msg_class(); \ | 967 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
954 static void Log(const Message* msg, std::wstring* l); \ | 968 Tuple2<type1_out&, type2_out&> >(MSG_ROUTING_CONTROL, ID, \ |
| 969 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4)) {} \ |
955 }; | 970 }; |
956 | 971 |
957 #define IPC_SYNC_MESSAGE_CONTROL2_3(msg_class, type1_in, type2_in, type1_out, ty
pe2_out, type3_out) \ | 972 #define IPC_SYNC_MESSAGE_CONTROL2_3(msg_class, type1_in, type2_in, type1_out, ty
pe2_out, type3_out) \ |
958 class msg_class : \ | 973 class msg_class : \ |
959 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ | 974 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
960 Tuple3<type1_out&, type2_out&, type3_out&> > { \ | 975 Tuple3<type1_out&, type2_out&, type3_out&> > { \ |
961 public: \ | 976 public: \ |
962 enum { ID = msg_class##__ID }; \ | 977 enum { ID = msg_class##__ID }; \ |
963 msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2_
out* arg4, type3_out* arg5); \ | 978 msg_class(const type1_in& arg1, const type2_in& arg2, type1_out* arg3, type2
_out* arg4, type3_out* arg5) \ |
964 ~msg_class(); \ | 979 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
965 static void Log(const Message* msg, std::wstring* l); \ | 980 Tuple3<type1_out&, type2_out&, type3_out&> >(MSG_ROUTING_CONTROL, \ |
| 981 ID, \ |
| 982 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4, *arg5)) {} \ |
966 }; | 983 }; |
967 | 984 |
968 #define IPC_SYNC_MESSAGE_CONTROL3_1(msg_class, type1_in, type2_in, type3_in, typ
e1_out) \ | 985 #define IPC_SYNC_MESSAGE_CONTROL3_1(msg_class, type1_in, type2_in, type3_in, typ
e1_out) \ |
969 class msg_class : \ | 986 class msg_class : \ |
970 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ | 987 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
971 Tuple1<type1_out&> > { \ | 988 Tuple1<type1_out&> > { \ |
972 public: \ | 989 public: \ |
973 enum { ID = msg_class##__ID }; \ | 990 enum { ID = msg_class##__ID }; \ |
974 msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, t
ype1_out* arg4); \ | 991 msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3,
type1_out* arg4) \ |
975 ~msg_class(); \ | 992 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
976 static void Log(const Message* msg, std::wstring* l); \ | 993 Tuple1<type1_out&> >(MSG_ROUTING_CONTROL, ID, \ |
| 994 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4)) {} \ |
977 }; | 995 }; |
978 | 996 |
979 #define IPC_SYNC_MESSAGE_CONTROL3_2(msg_class, type1_in, type2_in, type3_in, typ
e1_out, type2_out) \ | 997 #define IPC_SYNC_MESSAGE_CONTROL3_2(msg_class, type1_in, type2_in, type3_in, typ
e1_out, type2_out) \ |
980 class msg_class : \ | 998 class msg_class : \ |
981 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ | 999 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
982 Tuple2<type1_out&, type2_out&> > { \ | 1000 Tuple2<type1_out&, type2_out&> > { \ |
983 public: \ | 1001 public: \ |
984 enum { ID = msg_class##__ID }; \ | 1002 enum { ID = msg_class##__ID }; \ |
985 msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, t
ype1_out* arg4, type2_out* arg5); \ | 1003 msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3,
type1_out* arg4, type2_out* arg5) \ |
986 ~msg_class(); \ | 1004 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
987 static void Log(const Message* msg, std::wstring* l); \ | 1005 Tuple2<type1_out&, type2_out&> >(MSG_ROUTING_CONTROL, ID, \ |
| 1006 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5)) {} \ |
988 }; | 1007 }; |
989 | 1008 |
990 #define IPC_SYNC_MESSAGE_CONTROL3_3(msg_class, type1_in, type2_in, type3_in, typ
e1_out, type2_out, type3_out) \ | 1009 #define IPC_SYNC_MESSAGE_CONTROL3_3(msg_class, type1_in, type2_in, type3_in, typ
e1_out, type2_out, type3_out) \ |
991 class msg_class : \ | 1010 class msg_class : \ |
992 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ | 1011 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
993 Tuple3<type1_out&, type2_out&, type3_out&> > { \ | 1012 Tuple3<type1_out&, type2_out&, type3_out&> > { \ |
994 public: \ | 1013 public: \ |
995 enum { ID = msg_class##__ID }; \ | 1014 enum { ID = msg_class##__ID }; \ |
996 msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, t
ype1_out* arg4, type2_out* arg5, type3_out* arg6); \ | 1015 msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3,
type1_out* arg4, type2_out* arg5, type3_out* arg6) \ |
997 ~msg_class(); \ | 1016 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
998 static void Log(const Message* msg, std::wstring* l); \ | 1017 Tuple3<type1_out&, type2_out&, type3_out&> >(MSG_ROUTING_CONTROL, \ |
| 1018 ID, \ |
| 1019 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5, *arg6)) {
} \ |
999 }; | 1020 }; |
1000 | 1021 |
1001 #define IPC_SYNC_MESSAGE_CONTROL4_1(msg_class, type1_in, type2_in, type3_in, typ
e4_in, type1_out) \ | 1022 #define IPC_SYNC_MESSAGE_CONTROL4_1(msg_class, type1_in, type2_in, type3_in, typ
e4_in, type1_out) \ |
1002 class msg_class : \ | 1023 class msg_class : \ |
1003 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ | 1024 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ |
1004 Tuple1<type1_out&> > { \ | 1025 Tuple1<type1_out&> > { \ |
1005 public: \ | 1026 public: \ |
1006 enum { ID = msg_class##__ID }; \ | 1027 enum { ID = msg_class##__ID }; \ |
1007 msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, c
onst type4_in& arg4, type1_out* arg6); \ | 1028 msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3,
const type4_in& arg4, type1_out* arg6) \ |
1008 ~msg_class(); \ | 1029 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>,
\ |
1009 static void Log(const Message* msg, std::wstring* l); \ | 1030 Tuple1<type1_out&> >(MSG_ROUTING_CONTROL, ID, \ |
| 1031 MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg6)) {} \ |
1010 }; | 1032 }; |
1011 | 1033 |
1012 #define IPC_SYNC_MESSAGE_CONTROL4_2(msg_class, type1_in, type2_in, type3_in, typ
e4_in, type1_out, type2_out) \ | 1034 #define IPC_SYNC_MESSAGE_CONTROL4_2(msg_class, type1_in, type2_in, type3_in, typ
e4_in, type1_out, type2_out) \ |
1013 class msg_class : \ | 1035 class msg_class : \ |
1014 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ | 1036 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ |
1015 Tuple2<type1_out&, type2_out&> > { \ | 1037 Tuple2<type1_out&, type2_out&> > { \ |
1016 public: \ | 1038 public: \ |
1017 enum { ID = msg_class##__ID }; \ | 1039 enum { ID = msg_class##__ID }; \ |
1018 msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3, c
onst type4_in& arg4, type1_out* arg5, type2_out* arg6); \ | 1040 msg_class(const type1_in& arg1, const type2_in& arg2, const type3_in& arg3,
const type4_in& arg4, type1_out* arg5, type2_out* arg6) \ |
1019 ~msg_class(); \ | 1041 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>,
\ |
1020 static void Log(const Message* msg, std::wstring* l); \ | 1042 Tuple2<type1_out&, type2_out&> >(MSG_ROUTING_CONTROL, ID, \ |
| 1043 MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg5, *arg6)) {}
\ |
| 1044 }; |
| 1045 |
| 1046 #define IPC_SYNC_MESSAGE_ROUTED0_1(msg_class, type1_out) \ |
| 1047 class msg_class : public IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> > {
\ |
| 1048 public: \ |
| 1049 enum { ID = msg_class##__ID }; \ |
| 1050 msg_class(int routing_id, type1_out* arg1) \ |
| 1051 : IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> >( \ |
| 1052 routing_id, ID, \ |
| 1053 MakeTuple(), MakeRefTuple(*arg1)) {} \ |
1021 }; | 1054 }; |
1022 | 1055 |
1023 #define IPC_SYNC_MESSAGE_ROUTED0_0(msg_class) \ | 1056 #define IPC_SYNC_MESSAGE_ROUTED0_0(msg_class) \ |
1024 class msg_class : public IPC::MessageWithReply<Tuple0, Tuple0 > { \ | 1057 class msg_class : public IPC::MessageWithReply<Tuple0, Tuple0 > { \ |
1025 public: \ | 1058 public: \ |
1026 enum { ID = msg_class##__ID }; \ | 1059 enum { ID = msg_class##__ID }; \ |
1027 msg_class(int routing_id); \ | 1060 msg_class(int routing_id) \ |
1028 ~msg_class(); \ | 1061 : IPC::MessageWithReply<Tuple0, Tuple0 >( \ |
1029 static void Log(const Message* msg, std::wstring* l); \ | 1062 routing_id, ID, \ |
1030 }; | 1063 MakeTuple(), MakeTuple()) {} \ |
1031 | |
1032 #define IPC_SYNC_MESSAGE_ROUTED0_1(msg_class, type1_out) \ | |
1033 class msg_class : public IPC::MessageWithReply<Tuple0, Tuple1<type1_out&> > {
\ | |
1034 public: \ | |
1035 enum { ID = msg_class##__ID }; \ | |
1036 msg_class(int routing_id, type1_out* arg1); \ | |
1037 ~msg_class(); \ | |
1038 static void Log(const Message* msg, std::wstring* l); \ | |
1039 }; | 1064 }; |
1040 | 1065 |
1041 #define IPC_SYNC_MESSAGE_ROUTED0_2(msg_class, type1_out, type2_out) \ | 1066 #define IPC_SYNC_MESSAGE_ROUTED0_2(msg_class, type1_out, type2_out) \ |
1042 class msg_class : \ | 1067 class msg_class : \ |
1043 public IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> > { \ | 1068 public IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> > { \ |
1044 public: \ | 1069 public: \ |
1045 enum { ID = msg_class##__ID }; \ | 1070 enum { ID = msg_class##__ID }; \ |
1046 msg_class(int routing_id, type1_out* arg1, type2_out* arg2); \ | 1071 msg_class(int routing_id, type1_out* arg1, type2_out* arg2) \ |
1047 ~msg_class(); \ | 1072 : IPC::MessageWithReply<Tuple0, Tuple2<type1_out&, type2_out&> >( \ |
1048 static void Log(const Message* msg, std::wstring* l); \ | 1073 routing_id, ID, \ |
| 1074 MakeTuple(), MakeRefTuple(*arg1, *arg2)) {} \ |
1049 }; | 1075 }; |
1050 | 1076 |
1051 #define IPC_SYNC_MESSAGE_ROUTED0_3(msg_class, type1_out, type2_out, type3_out) \ | 1077 #define IPC_SYNC_MESSAGE_ROUTED0_3(msg_class, type1_out, type2_out, type3_out) \ |
1052 class msg_class : \ | 1078 class msg_class : \ |
1053 public IPC::MessageWithReply<Tuple0, \ | 1079 public IPC::MessageWithReply<Tuple0, \ |
1054 Tuple3<type1_out&, type2_out&, type3_out&> >{ \ | 1080 Tuple3<type1_out&, type2_out&, type3_out&> >{ \ |
1055 public: \ | 1081 public: \ |
1056 enum { ID = msg_class##__ID }; \ | 1082 enum { ID = msg_class##__ID }; \ |
1057 msg_class(int routing_id, type1_out* arg1, type2_out* arg2, type3_out* arg3);
\ | 1083 msg_class(int routing_id, type1_out* arg1, type2_out* arg2, type3_out* arg3)
\ |
1058 ~msg_class(); \ | 1084 : IPC::MessageWithReply<Tuple0, \ |
1059 static void Log(const Message* msg, std::wstring* l); \ | 1085 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 1086 MakeTuple(), MakeRefTuple(*arg1, *arg2, *arg3)) {} \ |
1060 }; | 1087 }; |
1061 | 1088 |
1062 #define IPC_SYNC_MESSAGE_ROUTED1_0(msg_class, type1_in) \ | 1089 #define IPC_SYNC_MESSAGE_ROUTED1_0(msg_class, type1_in) \ |
1063 class msg_class : \ | 1090 class msg_class : \ |
1064 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 > { \ | 1091 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 > { \ |
1065 public: \ | 1092 public: \ |
1066 enum { ID = msg_class##__ID }; \ | 1093 enum { ID = msg_class##__ID }; \ |
1067 msg_class(int routing_id, const type1_in& arg1); \ | 1094 msg_class(int routing_id, const type1_in& arg1) \ |
1068 ~msg_class(); \ | 1095 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple0 >( \ |
1069 static void Log(const Message* msg, std::wstring* l); \ | 1096 routing_id, ID, \ |
| 1097 MakeRefTuple(arg1), MakeTuple()) {} \ |
1070 }; | 1098 }; |
1071 | 1099 |
1072 #define IPC_SYNC_MESSAGE_ROUTED1_1(msg_class, type1_in, type1_out) \ | 1100 #define IPC_SYNC_MESSAGE_ROUTED1_1(msg_class, type1_in, type1_out) \ |
1073 class msg_class : \ | 1101 class msg_class : \ |
1074 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> > { \ | 1102 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> > { \ |
1075 public: \ | 1103 public: \ |
1076 enum { ID = msg_class##__ID }; \ | 1104 enum { ID = msg_class##__ID }; \ |
1077 msg_class(int routing_id, const type1_in& arg1, type1_out* arg2); \ | 1105 msg_class(int routing_id, const type1_in& arg1, type1_out* arg2) \ |
1078 ~msg_class(); \ | 1106 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple1<type1_out&> >( \ |
1079 static void Log(const Message* msg, std::wstring* l); \ | 1107 routing_id, ID, \ |
| 1108 MakeRefTuple(arg1), MakeRefTuple(*arg2)) {} \ |
1080 }; | 1109 }; |
1081 | 1110 |
1082 #define IPC_SYNC_MESSAGE_ROUTED1_2(msg_class, type1_in, type1_out, type2_out) \ | 1111 #define IPC_SYNC_MESSAGE_ROUTED1_2(msg_class, type1_in, type1_out, type2_out) \ |
1083 class msg_class : \ | 1112 class msg_class : \ |
1084 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple2<type1_out&, type2_ou
t&> > { \ | 1113 public IPC::MessageWithReply<Tuple1<type1_in>, Tuple2<type1_out&, type2_ou
t&> > { \ |
1085 public: \ | 1114 public: \ |
1086 enum { ID = msg_class##__ID }; \ | 1115 enum { ID = msg_class##__ID }; \ |
1087 msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out* a
rg3); \ | 1116 msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out*
arg3) \ |
1088 ~msg_class(); \ | 1117 : IPC::MessageWithReply<Tuple1<type1_in>, Tuple2<type1_out&, type2_out&>
>( \ |
1089 static void Log(const Message* msg, std::wstring* l); \ | 1118 routing_id, ID, \ |
| 1119 MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3)) {} \ |
1090 }; | 1120 }; |
1091 | 1121 |
1092 #define IPC_SYNC_MESSAGE_ROUTED1_3(msg_class, type1_in, type1_out, type2_out, ty
pe3_out) \ | 1122 #define IPC_SYNC_MESSAGE_ROUTED1_3(msg_class, type1_in, type1_out, type2_out, ty
pe3_out) \ |
1093 class msg_class : \ | 1123 class msg_class : \ |
1094 public IPC::MessageWithReply<Tuple1<type1_in>, \ | 1124 public IPC::MessageWithReply<Tuple1<type1_in>, \ |
1095 Tuple3<type1_out&, type2_out&, type3_out&> >{ \ | 1125 Tuple3<type1_out&, type2_out&, type3_out&> >{ \ |
1096 public: \ | 1126 public: \ |
1097 enum { ID = msg_class##__ID }; \ | 1127 enum { ID = msg_class##__ID }; \ |
1098 msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out* a
rg3, type3_out* arg4); \ | 1128 msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out*
arg3, type3_out* arg4) \ |
1099 ~msg_class(); \ | 1129 : IPC::MessageWithReply<Tuple1<type1_in>, \ |
1100 static void Log(const Message* msg, std::wstring* l); \ | 1130 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 1131 MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3, *arg4)) {} \ |
1101 }; | 1132 }; |
1102 | 1133 |
1103 #define IPC_SYNC_MESSAGE_ROUTED1_4(msg_class, type1_in, type1_out, type2_out, ty
pe3_out, type4_out) \ | 1134 #define IPC_SYNC_MESSAGE_ROUTED1_4(msg_class, type1_in, type1_out, type2_out, ty
pe3_out, type4_out) \ |
1104 class msg_class : \ | 1135 class msg_class : \ |
1105 public IPC::MessageWithReply<Tuple1<type1_in>, \ | 1136 public IPC::MessageWithReply<Tuple1<type1_in>, \ |
1106 Tuple4<type1_out&, type2_out&, type3_out&, type4_out&> >{ \ | 1137 Tuple4<type1_out&, type2_out&, type3_out&, type4_out&> >{ \ |
1107 public: \ | 1138 public: \ |
1108 enum { ID = msg_class##__ID }; \ | 1139 enum { ID = msg_class##__ID }; \ |
1109 msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out* a
rg3, type3_out* arg4, type4_out* arg5); \ | 1140 msg_class(int routing_id, const type1_in& arg1, type1_out* arg2, type2_out*
arg3, type3_out* arg4, type4_out* arg5) \ |
1110 ~msg_class(); \ | 1141 : IPC::MessageWithReply<Tuple1<type1_in>, \ |
1111 static void Log(const Message* msg, std::wstring* l); \ | 1142 Tuple4<type1_out&, type2_out&, type3_out&, type4_out&> >(routing_id,
ID, \ |
| 1143 MakeRefTuple(arg1), MakeRefTuple(*arg2, *arg3, *arg4, *arg5)) {} \ |
1112 }; | 1144 }; |
1113 | 1145 |
1114 #define IPC_SYNC_MESSAGE_ROUTED2_0(msg_class, type1_in, type2_in) \ | 1146 #define IPC_SYNC_MESSAGE_ROUTED2_0(msg_class, type1_in, type2_in) \ |
1115 class msg_class : \ | 1147 class msg_class : \ |
1116 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 > { \ | 1148 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 > { \ |
1117 public: \ | 1149 public: \ |
1118 enum { ID = msg_class##__ID }; \ | 1150 enum { ID = msg_class##__ID }; \ |
1119 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2); \ | 1151 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2) \ |
1120 ~msg_class(); \ | 1152 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple0 >( \ |
1121 static void Log(const Message* msg, std::wstring* l); \ | 1153 routing_id, ID, \ |
| 1154 MakeRefTuple(arg1, arg2), MakeTuple()) {} \ |
1122 }; | 1155 }; |
1123 | 1156 |
1124 #define IPC_SYNC_MESSAGE_ROUTED2_1(msg_class, type1_in, type2_in, type1_out) \ | 1157 #define IPC_SYNC_MESSAGE_ROUTED2_1(msg_class, type1_in, type2_in, type1_out) \ |
1125 class msg_class : \ | 1158 class msg_class : \ |
1126 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple1<type1_out&
> > { \ | 1159 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple1<type1_out&
> > { \ |
1127 public: \ | 1160 public: \ |
1128 enum { ID = msg_class##__ID }; \ | 1161 enum { ID = msg_class##__ID }; \ |
1129 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_o
ut* arg3); \ | 1162 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_
out* arg3) \ |
1130 ~msg_class(); \ | 1163 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, Tuple1<type1_out&> >
( \ |
1131 static void Log(const Message* msg, std::wstring* l); \ | 1164 routing_id, ID, \ |
| 1165 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3)) {} \ |
1132 }; | 1166 }; |
1133 | 1167 |
1134 #define IPC_SYNC_MESSAGE_ROUTED2_2(msg_class, type1_in, type2_in, type1_out, typ
e2_out) \ | 1168 #define IPC_SYNC_MESSAGE_ROUTED2_2(msg_class, type1_in, type2_in, type1_out, typ
e2_out) \ |
1135 class msg_class : \ | 1169 class msg_class : \ |
1136 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ | 1170 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
1137 Tuple2<type1_out&, type2_out&> > { \ | 1171 Tuple2<type1_out&, type2_out&> > { \ |
1138 public: \ | 1172 public: \ |
1139 enum { ID = msg_class##__ID }; \ | 1173 enum { ID = msg_class##__ID }; \ |
1140 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_o
ut* arg3, type2_out* arg4); \ | 1174 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_
out* arg3, type2_out* arg4) \ |
1141 ~msg_class(); \ | 1175 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
1142 static void Log(const Message* msg, std::wstring* l); \ | 1176 Tuple2<type1_out&, type2_out&> >(routing_id, ID, \ |
| 1177 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4)) {} \ |
1143 }; | 1178 }; |
1144 | 1179 |
1145 #define IPC_SYNC_MESSAGE_ROUTED2_3(msg_class, type1_in, type2_in, type1_out, typ
e2_out, type3_out) \ | 1180 #define IPC_SYNC_MESSAGE_ROUTED2_3(msg_class, type1_in, type2_in, type1_out, typ
e2_out, type3_out) \ |
1146 class msg_class : \ | 1181 class msg_class : \ |
1147 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ | 1182 public IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
1148 Tuple3<type1_out&, type2_out&, type3_out&> > { \ | 1183 Tuple3<type1_out&, type2_out&, type3_out&> > { \ |
1149 public: \ | 1184 public: \ |
1150 enum { ID = msg_class##__ID }; \ | 1185 enum { ID = msg_class##__ID }; \ |
1151 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_o
ut* arg3, type2_out* arg4, type3_out* arg5); \ | 1186 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, type1_
out* arg3, type2_out* arg4, type3_out* arg5) \ |
1152 ~msg_class(); \ | 1187 : IPC::MessageWithReply<Tuple2<type1_in, type2_in>, \ |
1153 static void Log(const Message* msg, std::wstring* l); \ | 1188 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 1189 MakeRefTuple(arg1, arg2), MakeRefTuple(*arg3, *arg4, *arg5)) {} \ |
1154 }; | 1190 }; |
1155 | 1191 |
1156 #define IPC_SYNC_MESSAGE_ROUTED3_0(msg_class, type1_in, type2_in, type3_in) \ | 1192 #define IPC_SYNC_MESSAGE_ROUTED3_0(msg_class, type1_in, type2_in, type3_in) \ |
1157 class msg_class : \ | 1193 class msg_class : \ |
1158 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, Tuple0
> { \ | 1194 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, Tuple0
> { \ |
1159 public: \ | 1195 public: \ |
1160 enum { ID = msg_class##__ID }; \ | 1196 enum { ID = msg_class##__ID }; \ |
1161 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3); \ | 1197 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3) \ |
1162 ~msg_class(); \ | 1198 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, Tuple0>( \ |
1163 static void Log(const Message* msg, std::wstring* l); \ | 1199 routing_id, ID, \ |
1164 }; | 1200 MakeRefTuple(arg1, arg2, arg3), MakeTuple()) {} \ |
| 1201 }; |
1165 | 1202 |
1166 #define IPC_SYNC_MESSAGE_ROUTED3_1(msg_class, type1_in, type2_in, type3_in, type
1_out) \ | 1203 #define IPC_SYNC_MESSAGE_ROUTED3_1(msg_class, type1_in, type2_in, type3_in, type
1_out) \ |
1167 class msg_class : \ | 1204 class msg_class : \ |
1168 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ | 1205 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
1169 Tuple1<type1_out&> > { \ | 1206 Tuple1<type1_out&> > { \ |
1170 public: \ | 1207 public: \ |
1171 enum { ID = msg_class##__ID }; \ | 1208 enum { ID = msg_class##__ID }; \ |
1172 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, type1_out* arg4); \ | 1209 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, type1_out* arg4) \ |
1173 ~msg_class(); \ | 1210 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
1174 static void Log(const Message* msg, std::wstring* l); \ | 1211 Tuple1<type1_out&> >(routing_id, ID, \ |
| 1212 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4)) {} \ |
1175 }; | 1213 }; |
1176 | 1214 |
1177 #define IPC_SYNC_MESSAGE_ROUTED3_2(msg_class, type1_in, type2_in, type3_in, type
1_out, type2_out) \ | 1215 #define IPC_SYNC_MESSAGE_ROUTED3_2(msg_class, type1_in, type2_in, type3_in, type
1_out, type2_out) \ |
1178 class msg_class : \ | 1216 class msg_class : \ |
1179 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ | 1217 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
1180 Tuple2<type1_out&, type2_out&> > { \ | 1218 Tuple2<type1_out&, type2_out&> > { \ |
1181 public: \ | 1219 public: \ |
1182 enum { ID = msg_class##__ID }; \ | 1220 enum { ID = msg_class##__ID }; \ |
1183 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, type1_out* arg4, type2_out* arg5); \ | 1221 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, type1_out* arg4, type2_out* arg5) \ |
1184 ~msg_class(); \ | 1222 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
1185 static void Log(const Message* msg, std::wstring* l); \ | 1223 Tuple2<type1_out&, type2_out&> >(routing_id, ID, \ |
| 1224 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5)) {} \ |
1186 }; | 1225 }; |
1187 | 1226 |
1188 #define IPC_SYNC_MESSAGE_ROUTED3_3(msg_class, type1_in, type2_in, type3_in, type
1_out, type2_out, type3_out) \ | 1227 #define IPC_SYNC_MESSAGE_ROUTED3_3(msg_class, type1_in, type2_in, type3_in, type
1_out, type2_out, type3_out) \ |
1189 class msg_class : \ | 1228 class msg_class : \ |
1190 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ | 1229 public IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
1191 Tuple3<type1_out&, type2_out&, type3_out&> > { \ | 1230 Tuple3<type1_out&, type2_out&, type3_out&> > { \ |
1192 public: \ | 1231 public: \ |
1193 enum { ID = msg_class##__ID }; \ | 1232 enum { ID = msg_class##__ID }; \ |
1194 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, type1_out* arg4, type2_out* arg5, type3_out* arg6); \ | 1233 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, type1_out* arg4, type2_out* arg5, type3_out* arg6) \ |
1195 ~msg_class(); \ | 1234 : IPC::MessageWithReply<Tuple3<type1_in, type2_in, type3_in>, \ |
1196 static void Log(const Message* msg, std::wstring* l); \ | 1235 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 1236 MakeRefTuple(arg1, arg2, arg3), MakeRefTuple(*arg4, *arg5, *arg6)) {
} \ |
1197 }; | 1237 }; |
1198 | 1238 |
1199 #define IPC_SYNC_MESSAGE_ROUTED4_0(msg_class, type1_in, type2_in, type3_in, type
4_in) \ | 1239 #define IPC_SYNC_MESSAGE_ROUTED4_0(msg_class, type1_in, type2_in, type3_in, type
4_in) \ |
1200 class msg_class : \ | 1240 class msg_class : \ |
1201 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ | 1241 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ |
1202 Tuple0 > { \ | 1242 Tuple0 > { \ |
1203 public: \ | 1243 public: \ |
1204 enum { ID = msg_class##__ID }; \ | 1244 enum { ID = msg_class##__ID }; \ |
1205 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, const type4_in& arg4); \ | 1245 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, const type4_in& arg4) \ |
1206 ~msg_class(); \ | 1246 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>,
\ |
1207 static void Log(const Message* msg, std::wstring* l); \ | 1247 Tuple0 >(routing_id, ID, \ |
| 1248 MakeRefTuple(arg1, arg2, arg3, arg4), MakeTuple()) {} \ |
1208 }; | 1249 }; |
1209 | 1250 |
1210 #define IPC_SYNC_MESSAGE_ROUTED4_1(msg_class, type1_in, type2_in, type3_in, type
4_in, type1_out) \ | 1251 #define IPC_SYNC_MESSAGE_ROUTED4_1(msg_class, type1_in, type2_in, type3_in, type
4_in, type1_out) \ |
1211 class msg_class : \ | 1252 class msg_class : \ |
1212 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ | 1253 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ |
1213 Tuple1<type1_out&> > { \ | 1254 Tuple1<type1_out&> > { \ |
1214 public: \ | 1255 public: \ |
1215 enum { ID = msg_class##__ID }; \ | 1256 enum { ID = msg_class##__ID }; \ |
1216 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, const type4_in& arg4, type1_out* arg6); \ | 1257 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, const type4_in& arg4, type1_out* arg6) \ |
1217 ~msg_class(); \ | 1258 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>,
\ |
1218 static void Log(const Message* msg, std::wstring* l); \ | 1259 Tuple1<type1_out&> >(routing_id, ID, \ |
| 1260 MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg6)) {} \ |
1219 }; | 1261 }; |
1220 | 1262 |
1221 #define IPC_SYNC_MESSAGE_ROUTED4_2(msg_class, type1_in, type2_in, type3_in, type
4_in, type1_out, type2_out) \ | 1263 #define IPC_SYNC_MESSAGE_ROUTED4_2(msg_class, type1_in, type2_in, type3_in, type
4_in, type1_out, type2_out) \ |
1222 class msg_class : \ | 1264 class msg_class : \ |
1223 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ | 1265 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ |
1224 Tuple2<type1_out&, type2_out&> > { \ | 1266 Tuple2<type1_out&, type2_out&> > { \ |
1225 public: \ | 1267 public: \ |
1226 enum { ID = msg_class##__ID }; \ | 1268 enum { ID = msg_class##__ID }; \ |
1227 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, const type4_in& arg4, type1_out* arg5, type2_out* arg6); \ | 1269 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, const type4_in& arg4, type1_out* arg5, type2_out* arg6) \ |
1228 ~msg_class(); \ | 1270 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>,
\ |
1229 static void Log(const Message* msg, std::wstring* l); \ | 1271 Tuple2<type1_out&, type2_out&> >(routing_id, ID, \ |
| 1272 MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg5, *arg6)) {}
\ |
1230 }; | 1273 }; |
1231 | 1274 |
1232 #define IPC_SYNC_MESSAGE_ROUTED4_3(msg_class, type1_in, type2_in, type3_in, type
4_in, type1_out, type2_out, type3_out) \ | 1275 #define IPC_SYNC_MESSAGE_ROUTED4_3(msg_class, type1_in, type2_in, type3_in, type
4_in, type1_out, type2_out, type3_out) \ |
1233 class msg_class : \ | 1276 class msg_class : \ |
1234 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ | 1277 public IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in
>, \ |
1235 Tuple3<type1_out&, type2_out&, type3_out&> > { \ | 1278 Tuple3<type1_out&, type2_out&, type3_out&> > { \ |
1236 public: \ | 1279 public: \ |
1237 enum { ID = msg_class##__ID }; \ | 1280 enum { ID = msg_class##__ID }; \ |
1238 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, const type4_in& arg4, type1_out* arg5, type2_out* arg6, type3_out
* arg7); \ | 1281 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, const type4_in& arg4, type1_out* arg5, type2_out* arg6, type3_ou
t* arg7) \ |
1239 ~msg_class(); \ | 1282 : IPC::MessageWithReply<Tuple4<type1_in, type2_in, type3_in, type4_in>, \ |
1240 static void Log(const Message* msg, std::wstring* l); \ | 1283 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 1284 MakeRefTuple(arg1, arg2, arg3, arg4), MakeRefTuple(*arg5, *arg6, *arg7
)) {} \ |
1241 }; | 1285 }; |
1242 | 1286 |
1243 #define IPC_SYNC_MESSAGE_ROUTED5_0(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in) \ | 1287 #define IPC_SYNC_MESSAGE_ROUTED5_0(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in) \ |
1244 class msg_class : \ | 1288 class msg_class : \ |
1245 public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in
, type5_in>, \ | 1289 public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in
, type5_in>, \ |
1246 Tuple0 > { \ | 1290 Tuple0 > { \ |
1247 public: \ | 1291 public: \ |
1248 enum { ID = msg_class##__ID }; \ | 1292 enum { ID = msg_class##__ID }; \ |
1249 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, const type4_in& arg4, const type5_in& arg5); \ | 1293 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, const type4_in& arg4, const type5_in& arg5) \ |
1250 ~msg_class(); \ | 1294 : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, t
ype5_in>, \ |
1251 static void Log(const Message* msg, std::wstring* l); \ | 1295 Tuple0 >(routing_id, ID, \ |
| 1296 MakeRefTuple(arg1, arg2, arg3, arg4, arg5), MakeTuple()) {} \ |
1252 }; | 1297 }; |
1253 | 1298 |
1254 #define IPC_SYNC_MESSAGE_ROUTED5_1(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in, type1_out) \ | 1299 #define IPC_SYNC_MESSAGE_ROUTED5_1(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in, type1_out) \ |
1255 class msg_class : \ | 1300 class msg_class : \ |
1256 public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in
, type5_in>, \ | 1301 public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in
, type5_in>, \ |
1257 Tuple1<type1_out&> > { \ | 1302 Tuple1<type1_out&> > { \ |
1258 public: \ | 1303 public: \ |
1259 enum { ID = msg_class##__ID }; \ | 1304 enum { ID = msg_class##__ID }; \ |
1260 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, const type4_in& arg4, const type5_in& arg5, type1_out* arg6); \ | 1305 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, const type4_in& arg4, const type5_in& arg5, type1_out* arg6) \ |
1261 ~msg_class(); \ | 1306 : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, t
ype5_in>, \ |
1262 static void Log(const Message* msg, std::wstring* l); \ | 1307 Tuple1<type1_out&> >(routing_id, ID, \ |
| 1308 MakeRefTuple(arg1, arg2, arg3, arg4, arg5), MakeRefTuple(*arg6)) {}
\ |
1263 }; | 1309 }; |
1264 | 1310 |
1265 #define IPC_SYNC_MESSAGE_ROUTED5_2(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in, type1_out, type2_out) \ | 1311 #define IPC_SYNC_MESSAGE_ROUTED5_2(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in, type1_out, type2_out) \ |
1266 class msg_class : \ | 1312 class msg_class : \ |
1267 public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in
, type5_in>, \ | 1313 public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in
, type5_in>, \ |
1268 Tuple2<type1_out&, type2_out&> > { \ | 1314 Tuple2<type1_out&, type2_out&> > { \ |
1269 public: \ | 1315 public: \ |
1270 enum { ID = msg_class##__ID }; \ | 1316 enum { ID = msg_class##__ID }; \ |
1271 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, const type4_in& arg4, const type4_in& arg5, type1_out* arg6, type
2_out* arg7); \ | 1317 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, const type4_in& arg4, const type4_in& arg5, type1_out* arg6, typ
e2_out* arg7) \ |
1272 ~msg_class(); \ | 1318 : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, t
ype5_in>, \ |
1273 static void Log(const Message* msg, std::wstring* l); \ | 1319 Tuple2<type1_out&, type2_out&> >(routing_id, ID, \ |
| 1320 MakeRefTuple(arg1, arg2, arg3, arg4, arg5), MakeRefTuple(*arg6, *arg
7)) {} \ |
1274 }; | 1321 }; |
1275 | 1322 |
1276 #define IPC_SYNC_MESSAGE_ROUTED5_3(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in, type1_out, type2_out, type3_out) \ | 1323 #define IPC_SYNC_MESSAGE_ROUTED5_3(msg_class, type1_in, type2_in, type3_in, type
4_in, type5_in, type1_out, type2_out, type3_out) \ |
1277 class msg_class : \ | 1324 class msg_class : \ |
1278 public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in
, type5_in>, \ | 1325 public IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in
, type5_in>, \ |
1279 Tuple3<type1_out&, type2_out&, type3_out&> > { \ | 1326 Tuple3<type1_out&, type2_out&, type3_out&> > { \ |
1280 public: \ | 1327 public: \ |
1281 enum { ID = msg_class##__ID }; \ | 1328 enum { ID = msg_class##__ID }; \ |
1282 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const t
ype3_in& arg3, const type4_in& arg4, const type4_in& arg5, type1_out* arg6, type
2_out* arg7, type3_out* arg8); \ | 1329 msg_class(int routing_id, const type1_in& arg1, const type2_in& arg2, const
type3_in& arg3, const type4_in& arg4, const type4_in& arg5, type1_out* arg6, typ
e2_out* arg7, type3_out* arg8) \ |
1283 ~msg_class(); \ | 1330 : IPC::MessageWithReply<Tuple5<type1_in, type2_in, type3_in, type4_in, typ
e5_in>, \ |
1284 static void Log(const Message* msg, std::wstring* l); \ | 1331 Tuple3<type1_out&, type2_out&, type3_out&> >(routing_id, ID, \ |
| 1332 MakeRefTuple(arg1, arg2, arg3, arg4, arg5), MakeRefTuple(*arg6, *arg7,
*arg8)) {} \ |
1285 }; | 1333 }; |
1286 | 1334 |
1287 #endif // #if defined() | 1335 #endif // #if defined() |
OLD | NEW |