7ed94d8b96dd8d802ae2f89dfd452043ba34a6c5
[WebKit-https.git] / Source / WebKit2 / Platform / CoreIPC / Arguments.h
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef Arguments_h
27 #define Arguments_h
28
29 #include "ArgumentDecoder.h"
30 #include "ArgumentEncoder.h"
31 #include <wtf/TypeTraits.h>
32
33 namespace CoreIPC {
34     
35 struct Arguments0 {
36     typedef Arguments0 ValueType;
37
38     void encode(ArgumentEncoder&) const 
39     {
40     }
41
42     static bool decode(ArgumentDecoder*, Arguments0&)
43     {
44         return true;
45     }
46 };
47
48 template<typename T1> struct Arguments1 {
49     typedef Arguments1<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type> ValueType;
50
51     Arguments1()
52     {
53     }
54
55     Arguments1(T1 t1) 
56         : argument1(t1)
57     {
58     }
59
60     void encode(ArgumentEncoder& encoder) const
61     {
62         encoder.encode(argument1);
63     }
64
65     static bool decode(ArgumentDecoder* decoder, Arguments1& result)
66     {
67         return decoder->decode(result.argument1);
68     }
69     
70     T1 argument1;
71 };
72     
73 template<typename T1, typename T2> struct Arguments2 : Arguments1<T1> {
74     typedef Arguments2<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
75                        typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type> ValueType;
76
77     Arguments2() 
78     {
79     }
80
81     Arguments2(T1 t1, T2 t2) 
82         : Arguments1<T1>(t1)
83         , argument2(t2)
84     {
85     }
86
87     void encode(ArgumentEncoder& encoder) const
88     {
89         Arguments1<T1>::encode(encoder);
90         encoder.encode(argument2);
91     }
92
93     static bool decode(ArgumentDecoder* decoder, Arguments2& result)
94     {
95         if (!Arguments1<T1>::decode(decoder, result))
96             return false;
97         
98         return decoder->decode(result.argument2);
99     }
100
101     T2 argument2;
102 };
103
104 template<typename T1, typename T2, typename T3> struct Arguments3 : Arguments2<T1, T2> {
105     typedef Arguments3<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
106                        typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
107                        typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type> ValueType;
108
109     Arguments3()
110     {
111     }
112
113     Arguments3(T1 t1, T2 t2, T3 t3) 
114         : Arguments2<T1, T2>(t1, t2)
115         , argument3(t3)
116     {
117     }
118
119     void encode(ArgumentEncoder& encoder) const
120     {
121         Arguments2<T1, T2>::encode(encoder);
122         encoder.encode(argument3);
123     }
124
125     static bool decode(ArgumentDecoder* decoder, Arguments3& result)
126     {
127         if (!Arguments2<T1, T2>::decode(decoder, result))
128             return false;
129         
130         return decoder->decode(result.argument3);
131     }
132
133     T3 argument3;
134 };
135
136 template<typename T1, typename T2, typename T3, typename T4> struct Arguments4 : Arguments3<T1, T2, T3> {
137     typedef Arguments4<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
138                        typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
139                        typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type,
140                        typename WTF::RemoveConst<typename WTF::RemoveReference<T4>::Type>::Type> ValueType;
141
142     Arguments4()
143     {
144     }
145
146     Arguments4(T1 t1, T2 t2, T3 t3, T4 t4)
147         : Arguments3<T1, T2, T3>(t1, t2, t3)
148         , argument4(t4)
149     {
150     }
151
152     void encode(ArgumentEncoder& encoder) const
153     {
154         Arguments3<T1, T2, T3>::encode(encoder);
155         encoder.encode(argument4);
156     }
157     
158     static bool decode(ArgumentDecoder* decoder, Arguments4& result)
159     {
160         if (!Arguments3<T1, T2, T3>::decode(decoder, result))
161             return false;
162         
163         return decoder->decode(result.argument4);
164     }
165
166     T4 argument4;
167 };
168
169 template<typename T1, typename T2, typename T3, typename T4, typename T5> struct Arguments5 : Arguments4<T1, T2, T3, T4> {
170     typedef Arguments5<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
171                        typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
172                        typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type,
173                        typename WTF::RemoveConst<typename WTF::RemoveReference<T4>::Type>::Type,
174                        typename WTF::RemoveConst<typename WTF::RemoveReference<T5>::Type>::Type> ValueType;
175
176     Arguments5()
177     {
178     }
179
180     Arguments5(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
181         : Arguments4<T1, T2, T3, T4>(t1, t2, t3, t4)
182         , argument5(t5)
183     {
184     }
185
186     void encode(ArgumentEncoder& encoder) const
187     {
188         Arguments4<T1, T2, T3, T4>::encode(encoder);
189         encoder.encode(argument5);
190     }
191     
192     static bool decode(ArgumentDecoder* decoder, Arguments5& result)
193     {
194         if (!Arguments4<T1, T2, T3, T4>::decode(decoder, result))
195             return false;
196         
197         return decoder->decode(result.argument5);
198     }
199
200     T5 argument5;
201 };
202
203 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> struct Arguments6 : Arguments5<T1, T2, T3, T4, T5> {
204     typedef Arguments6<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
205                        typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
206                        typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type,
207                        typename WTF::RemoveConst<typename WTF::RemoveReference<T4>::Type>::Type,
208                        typename WTF::RemoveConst<typename WTF::RemoveReference<T5>::Type>::Type,
209                        typename WTF::RemoveConst<typename WTF::RemoveReference<T6>::Type>::Type> ValueType;
210
211     Arguments6()
212     {
213     }
214
215     Arguments6(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
216         : Arguments5<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5)
217         , argument6(t6)
218     {
219     }
220
221     void encode(ArgumentEncoder& encoder) const
222     {
223         Arguments5<T1, T2, T3, T4, T5>::encode(encoder);
224         encoder.encode(argument6);
225     }
226     
227     static bool decode(ArgumentDecoder* decoder, Arguments6& result)
228     {
229         if (!Arguments5<T1, T2, T3, T4, T5>::decode(decoder, result))
230             return false;
231         
232         return decoder->decode(result.argument6);
233     }
234
235     T6 argument6;
236 };
237
238 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> struct Arguments7 : Arguments6<T1, T2, T3, T4, T5, T6> {
239     typedef Arguments7<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
240                        typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
241                        typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type,
242                        typename WTF::RemoveConst<typename WTF::RemoveReference<T4>::Type>::Type,
243                        typename WTF::RemoveConst<typename WTF::RemoveReference<T5>::Type>::Type,
244                        typename WTF::RemoveConst<typename WTF::RemoveReference<T6>::Type>::Type,
245                        typename WTF::RemoveConst<typename WTF::RemoveReference<T7>::Type>::Type> ValueType;
246
247     Arguments7()
248     {
249     }
250
251     Arguments7(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
252         : Arguments6<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6)
253         , argument7(t7)
254     {
255     }
256
257     void encode(ArgumentEncoder& encoder) const
258     {
259         Arguments6<T1, T2, T3, T4, T5, T6>::encode(encoder);
260         encoder.encode(argument7);
261     }
262     
263     static bool decode(ArgumentDecoder* decoder, Arguments7& result)
264     {
265         if (!Arguments6<T1, T2, T3, T4, T5, T6>::decode(decoder, result))
266             return false;
267         
268         return decoder->decode(result.argument7);
269     }
270
271     T7 argument7;
272 };
273
274 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> {
275     typedef Arguments8<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
276     typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
277     typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type,
278     typename WTF::RemoveConst<typename WTF::RemoveReference<T4>::Type>::Type,
279     typename WTF::RemoveConst<typename WTF::RemoveReference<T5>::Type>::Type,
280     typename WTF::RemoveConst<typename WTF::RemoveReference<T6>::Type>::Type,
281     typename WTF::RemoveConst<typename WTF::RemoveReference<T7>::Type>::Type,
282     typename WTF::RemoveConst<typename WTF::RemoveReference<T8>::Type>::Type> ValueType;
283
284     Arguments8() { }
285     
286     Arguments8(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
287         : Arguments7<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7)
288         , argument8(t8)
289     {
290     }
291
292     void encode(ArgumentEncoder& encoder) const
293     {
294         Arguments7<T1, T2, T3, T4, T5, T6, T7>::encode(encoder);
295         encoder.encode(argument8);
296     }
297
298     static bool decode(ArgumentDecoder* decoder, Arguments8& result)
299     {
300         if (!Arguments7<T1, T2, T3, T4, T5, T6, T7>::decode(decoder, result))
301             return false;
302
303         return decoder->decode(result.argument8);
304     }
305
306     T8 argument8;
307 };
308
309 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> {
310     typedef Arguments10<typename WTF::RemoveConst<typename WTF::RemoveReference<T1>::Type>::Type,
311     typename WTF::RemoveConst<typename WTF::RemoveReference<T2>::Type>::Type,
312     typename WTF::RemoveConst<typename WTF::RemoveReference<T3>::Type>::Type,
313     typename WTF::RemoveConst<typename WTF::RemoveReference<T4>::Type>::Type,
314     typename WTF::RemoveConst<typename WTF::RemoveReference<T5>::Type>::Type,
315     typename WTF::RemoveConst<typename WTF::RemoveReference<T6>::Type>::Type,
316     typename WTF::RemoveConst<typename WTF::RemoveReference<T7>::Type>::Type,
317     typename WTF::RemoveConst<typename WTF::RemoveReference<T8>::Type>::Type,
318     typename WTF::RemoveConst<typename WTF::RemoveReference<T9>::Type>::Type,
319     typename WTF::RemoveConst<typename WTF::RemoveReference<T10>::Type>::Type> ValueType;
320
321     Arguments10() { }
322     
323     Arguments10(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10)
324         : Arguments8<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8)
325         , argument9(t9)
326         , argument10(t10)
327     {
328     }
329
330     void encode(ArgumentEncoder& encoder) const
331     {
332         Arguments8<T1, T2, T3, T4, T5, T6, T7, T8>::encode(encoder);
333         encoder.encode(argument9);
334         encoder.encode(argument10);
335     }
336
337     static bool decode(ArgumentDecoder* decoder, Arguments10& result)
338     {
339         if (!Arguments8<T1, T2, T3, T4, T5, T6, T7, T8>::decode(decoder, result))
340             return false;
341
342         decoder->decode(result.argument9);
343         return decoder->decode(result.argument10);
344     }
345
346     T9 argument9;
347     T10 argument10;
348 };
349
350 } // namespace CoreIPC
351
352 #endif // Arguments_h