1// BEGIN_Callable 10
2    /**
3      Callable represents a "callable" type, which is fundamentally
4      similar to an Invokable but is semantically richer.
5    */
6    template <typename R, class A1 = Void, class A2 = Void, class A3 = Void, class A4 = Void, class A5 = Void, class A6 = Void, class A7 = Void, class A8 = Void, class A9 = Void, class A10 = Void>
7    class Callable : public Invokable<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10> {
8		public:
9            typedef R ReturnT;
10            enum { NumArgs = 10 };
11
12        public:
13            /**
14              Creates a copy of this object and returns it. Caller owns
15              the returned object.
16            */
17            virtual Callable* clone() const = 0;
18
19            /** Exact behaviour is defined by subclass implementations. */
20            virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const = 0;
21
22            /** Same as calling this->operator()(...). */
23            ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
24            { return this->operator()(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); }
25
26            /** Same as calling this->operator()(...), except that the return value
27            of that method is ignored. */
28            void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
29            { this->operator()(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); }
30    };
31
32// END_Callable 10
33// BEGIN_Callable 9
34    // specialization
35    template <typename R,class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
36    class Callable<R, A1,A2,A3,A4,A5,A6,A7,A8,A9,Void> : public Invokable<A1,A2,A3,A4,A5,A6,A7,A8,A9> {
37		public:
38            typedef R ReturnT;
39            enum { NumArgs = 9 };
40
41        public:
42            /**
43              Creates a copy of this object and returns it. Caller owns
44              the returned object.
45            */
46            virtual Callable* clone() const = 0;
47
48            /** Exact behaviour is defined by subclass implementations. */
49            virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const = 0;
50
51            /** Same as calling this->operator()(...). */
52            ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
53            { return this->operator()(a1,a2,a3,a4,a5,a6,a7,a8,a9); }
54
55            /** Same as calling this->operator()(...), except that the return value
56            of that method is ignored. */
57            void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
58            { this->operator()(a1,a2,a3,a4,a5,a6,a7,a8,a9); }
59    };
60
61// END_Callable 9
62// BEGIN_Callable 8
63    // specialization
64    template <typename R,class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
65    class Callable<R, A1,A2,A3,A4,A5,A6,A7,A8,Void,Void> : public Invokable<A1,A2,A3,A4,A5,A6,A7,A8> {
66		public:
67            typedef R ReturnT;
68            enum { NumArgs = 8 };
69
70        public:
71            /**
72              Creates a copy of this object and returns it. Caller owns
73              the returned object.
74            */
75            virtual Callable* clone() const = 0;
76
77            /** Exact behaviour is defined by subclass implementations. */
78            virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const = 0;
79
80            /** Same as calling this->operator()(...). */
81            ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
82            { return this->operator()(a1,a2,a3,a4,a5,a6,a7,a8); }
83
84            /** Same as calling this->operator()(...), except that the return value
85            of that method is ignored. */
86            void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
87            { this->operator()(a1,a2,a3,a4,a5,a6,a7,a8); }
88    };
89
90// END_Callable 8
91// BEGIN_Callable 7
92    // specialization
93    template <typename R,class A1, class A2, class A3, class A4, class A5, class A6, class A7>
94    class Callable<R, A1,A2,A3,A4,A5,A6,A7,Void,Void,Void> : public Invokable<A1,A2,A3,A4,A5,A6,A7> {
95		public:
96            typedef R ReturnT;
97            enum { NumArgs = 7 };
98
99        public:
100            /**
101              Creates a copy of this object and returns it. Caller owns
102              the returned object.
103            */
104            virtual Callable* clone() const = 0;
105
106            /** Exact behaviour is defined by subclass implementations. */
107            virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const = 0;
108
109            /** Same as calling this->operator()(...). */
110            ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
111            { return this->operator()(a1,a2,a3,a4,a5,a6,a7); }
112
113            /** Same as calling this->operator()(...), except that the return value
114            of that method is ignored. */
115            void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
116            { this->operator()(a1,a2,a3,a4,a5,a6,a7); }
117    };
118
119// END_Callable 7
120// BEGIN_Callable 6
121    // specialization
122    template <typename R,class A1, class A2, class A3, class A4, class A5, class A6>
123    class Callable<R, A1,A2,A3,A4,A5,A6,Void,Void,Void,Void> : public Invokable<A1,A2,A3,A4,A5,A6> {
124		public:
125            typedef R ReturnT;
126            enum { NumArgs = 6 };
127
128        public:
129            /**
130              Creates a copy of this object and returns it. Caller owns
131              the returned object.
132            */
133            virtual Callable* clone() const = 0;
134
135            /** Exact behaviour is defined by subclass implementations. */
136            virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const = 0;
137
138            /** Same as calling this->operator()(...). */
139            ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
140            { return this->operator()(a1,a2,a3,a4,a5,a6); }
141
142            /** Same as calling this->operator()(...), except that the return value
143            of that method is ignored. */
144            void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
145            { this->operator()(a1,a2,a3,a4,a5,a6); }
146    };
147
148// END_Callable 6
149// BEGIN_Callable 5
150    // specialization
151    template <typename R,class A1, class A2, class A3, class A4, class A5>
152    class Callable<R, A1,A2,A3,A4,A5,Void,Void,Void,Void,Void> : public Invokable<A1,A2,A3,A4,A5> {
153		public:
154            typedef R ReturnT;
155            enum { NumArgs = 5 };
156
157        public:
158            /**
159              Creates a copy of this object and returns it. Caller owns
160              the returned object.
161            */
162            virtual Callable* clone() const = 0;
163
164            /** Exact behaviour is defined by subclass implementations. */
165            virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const = 0;
166
167            /** Same as calling this->operator()(...). */
168            ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
169            { return this->operator()(a1,a2,a3,a4,a5); }
170
171            /** Same as calling this->operator()(...), except that the return value
172            of that method is ignored. */
173            void invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
174            { this->operator()(a1,a2,a3,a4,a5); }
175    };
176
177// END_Callable 5
178// BEGIN_Callable 4
179    // specialization
180    template <typename R,class A1, class A2, class A3, class A4>
181    class Callable<R, A1,A2,A3,A4,Void,Void,Void,Void,Void,Void> : public Invokable<A1,A2,A3,A4> {
182		public:
183            typedef R ReturnT;
184            enum { NumArgs = 4 };
185
186        public:
187            /**
188              Creates a copy of this object and returns it. Caller owns
189              the returned object.
190            */
191            virtual Callable* clone() const = 0;
192
193            /** Exact behaviour is defined by subclass implementations. */
194            virtual ReturnT operator()(A1 a1, A2 a2, A3 a3, A4 a4) const = 0;
195
196            /** Same as calling this->operator()(...). */
197            ReturnT call(A1 a1, A2 a2, A3 a3, A4 a4) const
198            { return this->operator()(a1,a2,a3,a4); }
199
200            /** Same as calling this->operator()(...), except that the return value
201            of that method is ignored. */
202            void invoke(A1 a1, A2 a2, A3 a3, A4 a4) const
203            { this->operator()(a1,a2,a3,a4); }
204    };
205
206// END_Callable 4
207// BEGIN_Callable 3
208    // specialization
209    template <typename R,class A1, class A2, class A3>
210    class Callable<R, A1,A2,A3,Void,Void,Void,Void,Void,Void,Void> : public Invokable<A1,A2,A3> {
211		public:
212            typedef R ReturnT;
213            enum { NumArgs = 3 };
214
215        public:
216            /**
217              Creates a copy of this object and returns it. Caller owns
218              the returned object.
219            */
220            virtual Callable* clone() const = 0;
221
222            /** Exact behaviour is defined by subclass implementations. */
223            virtual ReturnT operator()(A1 a1, A2 a2, A3 a3) const = 0;
224
225            /** Same as calling this->operator()(...). */
226            ReturnT call(A1 a1, A2 a2, A3 a3) const
227            { return this->operator()(a1,a2,a3); }
228
229            /** Same as calling this->operator()(...), except that the return value
230            of that method is ignored. */
231            void invoke(A1 a1, A2 a2, A3 a3) const
232            { this->operator()(a1,a2,a3); }
233    };
234
235// END_Callable 3
236// BEGIN_Callable 2
237    // specialization
238    template <typename R,class A1, class A2>
239    class Callable<R, A1,A2,Void,Void,Void,Void,Void,Void,Void,Void> : public Invokable<A1,A2> {
240		public:
241            typedef R ReturnT;
242            enum { NumArgs = 2 };
243
244        public:
245            /**
246              Creates a copy of this object and returns it. Caller owns
247              the returned object.
248            */
249            virtual Callable* clone() const = 0;
250
251            /** Exact behaviour is defined by subclass implementations. */
252            virtual ReturnT operator()(A1 a1, A2 a2) const = 0;
253
254            /** Same as calling this->operator()(...). */
255            ReturnT call(A1 a1, A2 a2) const
256            { return this->operator()(a1,a2); }
257
258            /** Same as calling this->operator()(...), except that the return value
259            of that method is ignored. */
260            void invoke(A1 a1, A2 a2) const
261            { this->operator()(a1,a2); }
262    };
263
264// END_Callable 2
265// BEGIN_Callable 1
266    // specialization
267    template <typename R,class A1>
268    class Callable<R, A1,Void,Void,Void,Void,Void,Void,Void,Void,Void> : public Invokable<A1> {
269		public:
270            typedef R ReturnT;
271            enum { NumArgs = 1 };
272
273        public:
274            /**
275              Creates a copy of this object and returns it. Caller owns
276              the returned object.
277            */
278            virtual Callable* clone() const = 0;
279
280            /** Exact behaviour is defined by subclass implementations. */
281            virtual ReturnT operator()(A1 a1) const = 0;
282
283            /** Same as calling this->operator()(...). */
284            ReturnT call(A1 a1) const
285            { return this->operator()(a1); }
286
287            /** Same as calling this->operator()(...), except that the return value
288            of that method is ignored. */
289            void invoke(A1 a1) const
290            { this->operator()(a1); }
291    };
292
293// END_Callable 1
294// BEGIN_Callable 0
295    // specialization
296    template <typename R>
297    class Callable<R, Void,Void,Void,Void,Void,Void,Void,Void,Void,Void> : public Invokable<> {
298		public:
299            typedef R ReturnT;
300            enum { NumArgs = 0 };
301
302        public:
303            /**
304              Creates a copy of this object and returns it. Caller owns
305              the returned object.
306            */
307            virtual Callable* clone() const = 0;
308
309            /** Exact behaviour is defined by subclass implementations. */
310            virtual ReturnT operator()() const = 0;
311
312            /** Same as calling this->operator()(...). */
313            ReturnT call() const
314            { return this->operator()(); }
315
316            /** Same as calling this->operator()(...), except that the return value
317            of that method is ignored. */
318            void invoke() const
319            { this->operator()(); }
320    };
321
322// END_Callable 0
323