remoteprocedure.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2011 by Tommi Maekitalo
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * As a special exception, you may use this file as part of a free
10  * software library without restriction. Specifically, if other files
11  * instantiate templates or use macros or inline functions from this
12  * file, or you compile this file and link it with other files to
13  * produce an executable, this file does not by itself cause the
14  * resulting executable to be covered by the GNU General Public
15  * License. This exception does not however invalidate any other
16  * reasons why the executable file might be covered by the GNU Library
17  * General Public License.
18  *
19  * This library is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22  * Lesser General Public License for more details.
23  *
24  * You should have received a copy of the GNU Lesser General Public
25  * License along with this library; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27  */
28 
29 #ifndef CXXTOOLS_REMOTEPROCEDURE_H
30 #define CXXTOOLS_REMOTEPROCEDURE_H
31 
32 #include <cxxtools/remoteclient.h>
33 #include <cxxtools/remoteresult.h>
34 #include <cxxtools/composer.h>
35 #include <cxxtools/decomposer.h>
36 #include <cxxtools/signal.h>
37 #include <cxxtools/string.h>
38 #include <string>
39 
40 namespace cxxtools
41 {
42 
44 {
45  public:
47  : _client(&client)
48  , _name(name)
49  { }
50 
52  { cancel(); }
53 
55  { return *_client; }
56 
58  { _client = &client; }
59 
60  const String& name() const
61  { return _name; }
62 
63  virtual void setFault(int rc, const std::string& msg) = 0;
64 
65  virtual bool failed() const = 0;
66 
67  void cancel()
68  {
69  if (_client && _client->activeProcedure() == this)
70  _client->cancel();
71  }
72 
73  virtual void onFinished() = 0;
74 
75  private:
76  RemoteClient* _client;
77  String _name;
78 };
79 
80 
85 template <typename R>
87 {
88  public:
90  : IRemoteProcedure(client, name),
91  _result(client)
92  { }
93 
94  void setFault(int rc, const std::string& msg)
95  {
96  _result.setFault(rc, msg);
97  }
98 
100  const R& value() const
101  {
102  return _result.value();
103  }
104 
110 #if __cplusplus >= 201103L
111  R&& result()
112 #else
113  R& result()
114 #endif
115  {
116  return _result.get();
117  }
118 
119  virtual bool failed() const
120  {
121  return _result.failed();
122  }
123 
124  Signal< RemoteResult<R> & > finished;
125 
126 #if __cplusplus >= 201103L
128 #else
130 #endif
131  {
132  _result.client().wait(msecs);
133  return _result.get();
134  }
135 
136  protected:
137  void onFinished()
138  { finished.send(_result); }
139 
142 };
143 
144 
146 
148 
149 // generated with `remoteprocedure.pl -n 10`
151 template <typename R,
152  typename A1 = cxxtools::Void,
153  typename A2 = cxxtools::Void,
154  typename A3 = cxxtools::Void,
155  typename A4 = cxxtools::Void,
156  typename A5 = cxxtools::Void,
157  typename A6 = cxxtools::Void,
158  typename A7 = cxxtools::Void,
159  typename A8 = cxxtools::Void,
160  typename A9 = cxxtools::Void,
161  typename A10 = cxxtools::Void>
162 class RemoteProcedure : public RemoteProcedureBase<R>
163 {
164  public:
165  RemoteProcedure(RemoteClient& client, const String& name)
166  : RemoteProcedureBase<R>(client, name)
167  { }
168 
169  RemoteProcedure(RemoteClient& client, const char* name)
170  : RemoteProcedureBase<R>(client, String(name))
171  { }
172 
173  void begin(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
174  {
175  this->_result.clearFault();
176 
177  _a1.begin(a1);
178  _a2.begin(a2);
179  _a3.begin(a3);
180  _a4.begin(a4);
181  _a5.begin(a5);
182  _a6.begin(a6);
183  _a7.begin(a7);
184  _a8.begin(a8);
185  _a9.begin(a9);
186  _a10.begin(a10);
187 
188  this->_r.begin(this->_result.value());
189 
190  IDecomposer* argv[10] = { &_a1, &_a2, &_a3, &_a4, &_a5, &_a6, &_a7, &_a8, &_a9, &_a10 };
191  this->client().beginCall(this->_r, *this, argv, 10);
192  }
193 
194 #if __cplusplus >= 201103L
195  R&& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
196 #else
197  R& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
198 #endif
199  {
200  this->_result.clearFault();
201 
202  _a1.begin(a1);
203  _a2.begin(a2);
204  _a3.begin(a3);
205  _a4.begin(a4);
206  _a5.begin(a5);
207  _a6.begin(a6);
208  _a7.begin(a7);
209  _a8.begin(a8);
210  _a9.begin(a9);
211  _a10.begin(a10);
212  this->_r.begin(this->_result.value());
213 
214  IDecomposer* argv[10] = { &_a1, &_a2, &_a3, &_a4, &_a5, &_a6, &_a7, &_a8, &_a9, &_a10 };
215  this->client().call(this->_r, *this, argv, 10);
216  return this->_result.get();
217  }
218 
219 #if __cplusplus >= 201103L
220  R&& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
221 #else
222  R& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
223 #endif
224  {
225  return this->call(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
226  }
227 
228  private:
229  Decomposer<A1> _a1;
230  Decomposer<A2> _a2;
231  Decomposer<A3> _a3;
232  Decomposer<A4> _a4;
233  Decomposer<A5> _a5;
234  Decomposer<A6> _a6;
235  Decomposer<A7> _a7;
236  Decomposer<A8> _a8;
237  Decomposer<A9> _a9;
238  Decomposer<A10> _a10;
239 };
240 
241 
242 template <typename R,
243  typename A1,
244  typename A2,
245  typename A3,
246  typename A4,
247  typename A5,
248  typename A6,
249  typename A7,
250  typename A8,
251  typename A9>
252 class RemoteProcedure<R, A1, A2, A3, A4, A5, A6, A7, A8, A9,
253  cxxtools::Void> : public RemoteProcedureBase<R>
254 {
255  public:
256  RemoteProcedure(RemoteClient& client, const String& name)
257  : RemoteProcedureBase<R>(client, name)
258  { }
259 
260  RemoteProcedure(RemoteClient& client, const char* name)
261  : RemoteProcedureBase<R>(client, String(name))
262  { }
263 
264  void begin(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
265  {
266  this->_result.clearFault();
267 
268  _a1.begin(a1);
269  _a2.begin(a2);
270  _a3.begin(a3);
271  _a4.begin(a4);
272  _a5.begin(a5);
273  _a6.begin(a6);
274  _a7.begin(a7);
275  _a8.begin(a8);
276  _a9.begin(a9);
277 
278  this->_r.begin(this->_result.value());
279 
280  IDecomposer* argv[9] = { &_a1, &_a2, &_a3, &_a4, &_a5, &_a6, &_a7, &_a8, &_a9 };
281  this->client().beginCall(this->_r, *this, argv, 9);
282  }
283 
284 #if __cplusplus >= 201103L
285  R&& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
286 #else
287  R& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
288 #endif
289  {
290  this->_result.clearFault();
291 
292  _a1.begin(a1);
293  _a2.begin(a2);
294  _a3.begin(a3);
295  _a4.begin(a4);
296  _a5.begin(a5);
297  _a6.begin(a6);
298  _a7.begin(a7);
299  _a8.begin(a8);
300  _a9.begin(a9);
301  this->_r.begin(this->_result.value());
302 
303  IDecomposer* argv[9] = { &_a1, &_a2, &_a3, &_a4, &_a5, &_a6, &_a7, &_a8, &_a9 };
304  this->client().call(this->_r, *this, argv, 9);
305  return this->_result.get();
306  }
307 
308 #if __cplusplus >= 201103L
309  R&& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
310 #else
311  R& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
312 #endif
313  {
314  return this->call(a1, a2, a3, a4, a5, a6, a7, a8, a9);
315  }
316 
317  private:
318  Decomposer<A1> _a1;
319  Decomposer<A2> _a2;
320  Decomposer<A3> _a3;
321  Decomposer<A4> _a4;
322  Decomposer<A5> _a5;
323  Decomposer<A6> _a6;
324  Decomposer<A7> _a7;
325  Decomposer<A8> _a8;
326  Decomposer<A9> _a9;
327 };
328 
329 
330 template <typename R,
331  typename A1,
332  typename A2,
333  typename A3,
334  typename A4,
335  typename A5,
336  typename A6,
337  typename A7,
338  typename A8>
339 class RemoteProcedure<R, A1, A2, A3, A4, A5, A6, A7, A8,
340  cxxtools::Void,
341  cxxtools::Void> : public RemoteProcedureBase<R>
342 {
343  public:
344  RemoteProcedure(RemoteClient& client, const String& name)
345  : RemoteProcedureBase<R>(client, name)
346  { }
347 
348  RemoteProcedure(RemoteClient& client, const char* name)
349  : RemoteProcedureBase<R>(client, String(name))
350  { }
351 
352  void begin(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
353  {
354  this->_result.clearFault();
355 
356  _a1.begin(a1);
357  _a2.begin(a2);
358  _a3.begin(a3);
359  _a4.begin(a4);
360  _a5.begin(a5);
361  _a6.begin(a6);
362  _a7.begin(a7);
363  _a8.begin(a8);
364 
365  this->_r.begin(this->_result.value());
366 
367  IDecomposer* argv[8] = { &_a1, &_a2, &_a3, &_a4, &_a5, &_a6, &_a7, &_a8 };
368  this->client().beginCall(this->_r, *this, argv, 8);
369  }
370 
371 #if __cplusplus >= 201103L
372  R&& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
373 #else
374  R& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
375 #endif
376  {
377  this->_result.clearFault();
378 
379  _a1.begin(a1);
380  _a2.begin(a2);
381  _a3.begin(a3);
382  _a4.begin(a4);
383  _a5.begin(a5);
384  _a6.begin(a6);
385  _a7.begin(a7);
386  _a8.begin(a8);
387  this->_r.begin(this->_result.value());
388 
389  IDecomposer* argv[8] = { &_a1, &_a2, &_a3, &_a4, &_a5, &_a6, &_a7, &_a8 };
390  this->client().call(this->_r, *this, argv, 8);
391  return this->_result.get();
392  }
393 
394 #if __cplusplus >= 201103L
395  R&& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
396 #else
397  R& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
398 #endif
399  {
400  return this->call(a1, a2, a3, a4, a5, a6, a7, a8);
401  }
402 
403  private:
404  Decomposer<A1> _a1;
405  Decomposer<A2> _a2;
406  Decomposer<A3> _a3;
407  Decomposer<A4> _a4;
408  Decomposer<A5> _a5;
409  Decomposer<A6> _a6;
410  Decomposer<A7> _a7;
411  Decomposer<A8> _a8;
412 };
413 
414 
415 template <typename R,
416  typename A1,
417  typename A2,
418  typename A3,
419  typename A4,
420  typename A5,
421  typename A6,
422  typename A7>
423 class RemoteProcedure<R, A1, A2, A3, A4, A5, A6, A7,
424  cxxtools::Void,
426  cxxtools::Void> : public RemoteProcedureBase<R>
427 {
428  public:
429  RemoteProcedure(RemoteClient& client, const String& name)
430  : RemoteProcedureBase<R>(client, name)
431  { }
432 
433  RemoteProcedure(RemoteClient& client, const char* name)
434  : RemoteProcedureBase<R>(client, String(name))
435  { }
436 
437  void begin(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
438  {
439  this->_result.clearFault();
440 
441  _a1.begin(a1);
442  _a2.begin(a2);
443  _a3.begin(a3);
444  _a4.begin(a4);
445  _a5.begin(a5);
446  _a6.begin(a6);
447  _a7.begin(a7);
448 
449  this->_r.begin(this->_result.value());
450 
451  IDecomposer* argv[7] = { &_a1, &_a2, &_a3, &_a4, &_a5, &_a6, &_a7 };
452  this->client().beginCall(this->_r, *this, argv, 7);
453  }
454 
455 #if __cplusplus >= 201103L
456  R&& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
457 #else
458  R& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
459 #endif
460  {
461  this->_result.clearFault();
462 
463  _a1.begin(a1);
464  _a2.begin(a2);
465  _a3.begin(a3);
466  _a4.begin(a4);
467  _a5.begin(a5);
468  _a6.begin(a6);
469  _a7.begin(a7);
470  this->_r.begin(this->_result.value());
471 
472  IDecomposer* argv[7] = { &_a1, &_a2, &_a3, &_a4, &_a5, &_a6, &_a7 };
473  this->client().call(this->_r, *this, argv, 7);
474  return this->_result.get();
475  }
476 
477 #if __cplusplus >= 201103L
478  R&& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
479 #else
480  R& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
481 #endif
482  {
483  return this->call(a1, a2, a3, a4, a5, a6, a7);
484  }
485 
486  private:
487  Decomposer<A1> _a1;
488  Decomposer<A2> _a2;
489  Decomposer<A3> _a3;
490  Decomposer<A4> _a4;
491  Decomposer<A5> _a5;
492  Decomposer<A6> _a6;
493  Decomposer<A7> _a7;
494 };
495 
496 
497 template <typename R,
498  typename A1,
499  typename A2,
500  typename A3,
501  typename A4,
502  typename A5,
503  typename A6>
504 class RemoteProcedure<R, A1, A2, A3, A4, A5, A6,
505  cxxtools::Void,
508  cxxtools::Void> : public RemoteProcedureBase<R>
509 {
510  public:
511  RemoteProcedure(RemoteClient& client, const String& name)
512  : RemoteProcedureBase<R>(client, name)
513  { }
514 
515  RemoteProcedure(RemoteClient& client, const char* name)
516  : RemoteProcedureBase<R>(client, String(name))
517  { }
518 
519  void begin(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
520  {
521  this->_result.clearFault();
522 
523  _a1.begin(a1);
524  _a2.begin(a2);
525  _a3.begin(a3);
526  _a4.begin(a4);
527  _a5.begin(a5);
528  _a6.begin(a6);
529 
530  this->_r.begin(this->_result.value());
531 
532  IDecomposer* argv[6] = { &_a1, &_a2, &_a3, &_a4, &_a5, &_a6 };
533  this->client().beginCall(this->_r, *this, argv, 6);
534  }
535 
536 #if __cplusplus >= 201103L
537  R&& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
538 #else
539  R& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
540 #endif
541  {
542  this->_result.clearFault();
543 
544  _a1.begin(a1);
545  _a2.begin(a2);
546  _a3.begin(a3);
547  _a4.begin(a4);
548  _a5.begin(a5);
549  _a6.begin(a6);
550  this->_r.begin(this->_result.value());
551 
552  IDecomposer* argv[6] = { &_a1, &_a2, &_a3, &_a4, &_a5, &_a6 };
553  this->client().call(this->_r, *this, argv, 6);
554  return this->_result.get();
555  }
556 
557 #if __cplusplus >= 201103L
558  R&& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
559 #else
560  R& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
561 #endif
562  {
563  return this->call(a1, a2, a3, a4, a5, a6);
564  }
565 
566  private:
567  Decomposer<A1> _a1;
568  Decomposer<A2> _a2;
569  Decomposer<A3> _a3;
570  Decomposer<A4> _a4;
571  Decomposer<A5> _a5;
572  Decomposer<A6> _a6;
573 };
574 
575 
576 template <typename R,
577  typename A1,
578  typename A2,
579  typename A3,
580  typename A4,
581  typename A5>
582 class RemoteProcedure<R, A1, A2, A3, A4, A5,
583  cxxtools::Void,
587  cxxtools::Void> : public RemoteProcedureBase<R>
588 {
589  public:
590  RemoteProcedure(RemoteClient& client, const String& name)
591  : RemoteProcedureBase<R>(client, name)
592  { }
593 
594  RemoteProcedure(RemoteClient& client, const char* name)
595  : RemoteProcedureBase<R>(client, String(name))
596  { }
597 
598  void begin(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
599  {
600  this->_result.clearFault();
601 
602  _a1.begin(a1);
603  _a2.begin(a2);
604  _a3.begin(a3);
605  _a4.begin(a4);
606  _a5.begin(a5);
607 
608  this->_r.begin(this->_result.value());
609 
610  IDecomposer* argv[5] = { &_a1, &_a2, &_a3, &_a4, &_a5 };
611  this->client().beginCall(this->_r, *this, argv, 5);
612  }
613 
614 #if __cplusplus >= 201103L
615  R&& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
616 #else
617  R& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
618 #endif
619  {
620  this->_result.clearFault();
621 
622  _a1.begin(a1);
623  _a2.begin(a2);
624  _a3.begin(a3);
625  _a4.begin(a4);
626  _a5.begin(a5);
627  this->_r.begin(this->_result.value());
628 
629  IDecomposer* argv[5] = { &_a1, &_a2, &_a3, &_a4, &_a5 };
630  this->client().call(this->_r, *this, argv, 5);
631  return this->_result.get();
632  }
633 
634 #if __cplusplus >= 201103L
635  R&& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
636 #else
637  R& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
638 #endif
639  {
640  return this->call(a1, a2, a3, a4, a5);
641  }
642 
643  private:
644  Decomposer<A1> _a1;
645  Decomposer<A2> _a2;
646  Decomposer<A3> _a3;
647  Decomposer<A4> _a4;
648  Decomposer<A5> _a5;
649 };
650 
651 
652 template <typename R,
653  typename A1,
654  typename A2,
655  typename A3,
656  typename A4>
657 class RemoteProcedure<R, A1, A2, A3, A4,
658  cxxtools::Void,
663  cxxtools::Void> : public RemoteProcedureBase<R>
664 {
665  public:
666  RemoteProcedure(RemoteClient& client, const String& name)
667  : RemoteProcedureBase<R>(client, name)
668  { }
669 
670  RemoteProcedure(RemoteClient& client, const char* name)
671  : RemoteProcedureBase<R>(client, String(name))
672  { }
673 
674  void begin(const A1& a1, const A2& a2, const A3& a3, const A4& a4)
675  {
676  this->_result.clearFault();
677 
678  _a1.begin(a1);
679  _a2.begin(a2);
680  _a3.begin(a3);
681  _a4.begin(a4);
682 
683  this->_r.begin(this->_result.value());
684 
685  IDecomposer* argv[4] = { &_a1, &_a2, &_a3, &_a4 };
686  this->client().beginCall(this->_r, *this, argv, 4);
687  }
688 
689 #if __cplusplus >= 201103L
690  R&& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4)
691 #else
692  R& call(const A1& a1, const A2& a2, const A3& a3, const A4& a4)
693 #endif
694  {
695  this->_result.clearFault();
696 
697  _a1.begin(a1);
698  _a2.begin(a2);
699  _a3.begin(a3);
700  _a4.begin(a4);
701  this->_r.begin(this->_result.value());
702 
703  IDecomposer* argv[4] = { &_a1, &_a2, &_a3, &_a4 };
704  this->client().call(this->_r, *this, argv, 4);
705  return this->_result.get();
706  }
707 
708 #if __cplusplus >= 201103L
709  R&& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4)
710 #else
711  R& operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4)
712 #endif
713  {
714  return this->call(a1, a2, a3, a4);
715  }
716 
717  private:
718  Decomposer<A1> _a1;
719  Decomposer<A2> _a2;
720  Decomposer<A3> _a3;
721  Decomposer<A4> _a4;
722 };
723 
724 
725 template <typename R,
726  typename A1,
727  typename A2,
728  typename A3>
729 class RemoteProcedure<R, A1, A2, A3,
730  cxxtools::Void,
736  cxxtools::Void> : public RemoteProcedureBase<R>
737 {
738  public:
739  RemoteProcedure(RemoteClient& client, const String& name)
740  : RemoteProcedureBase<R>(client, name)
741  { }
742 
743  RemoteProcedure(RemoteClient& client, const char* name)
744  : RemoteProcedureBase<R>(client, String(name))
745  { }
746 
747  void begin(const A1& a1, const A2& a2, const A3& a3)
748  {
749  this->_result.clearFault();
750 
751  _a1.begin(a1);
752  _a2.begin(a2);
753  _a3.begin(a3);
754 
755  this->_r.begin(this->_result.value());
756 
757  IDecomposer* argv[3] = { &_a1, &_a2, &_a3 };
758  this->client().beginCall(this->_r, *this, argv, 3);
759  }
760 
761 #if __cplusplus >= 201103L
762  R&& call(const A1& a1, const A2& a2, const A3& a3)
763 #else
764  R& call(const A1& a1, const A2& a2, const A3& a3)
765 #endif
766  {
767  this->_result.clearFault();
768 
769  _a1.begin(a1);
770  _a2.begin(a2);
771  _a3.begin(a3);
772  this->_r.begin(this->_result.value());
773 
774  IDecomposer* argv[3] = { &_a1, &_a2, &_a3 };
775  this->client().call(this->_r, *this, argv, 3);
776  return this->_result.get();
777  }
778 
779 #if __cplusplus >= 201103L
780  R&& operator()(const A1& a1, const A2& a2, const A3& a3)
781 #else
782  R& operator()(const A1& a1, const A2& a2, const A3& a3)
783 #endif
784  {
785  return this->call(a1, a2, a3);
786  }
787 
788  private:
789  Decomposer<A1> _a1;
790  Decomposer<A2> _a2;
791  Decomposer<A3> _a3;
792 };
793 
794 
795 template <typename R,
796  typename A1,
797  typename A2>
798 class RemoteProcedure<R, A1, A2,
799  cxxtools::Void,
806  cxxtools::Void> : public RemoteProcedureBase<R>
807 {
808  public:
809  RemoteProcedure(RemoteClient& client, const String& name)
810  : RemoteProcedureBase<R>(client, name)
811  { }
812 
813  RemoteProcedure(RemoteClient& client, const char* name)
814  : RemoteProcedureBase<R>(client, String(name))
815  { }
816 
817  void begin(const A1& a1, const A2& a2)
818  {
819  this->_result.clearFault();
820 
821  _a1.begin(a1);
822  _a2.begin(a2);
823 
824  this->_r.begin(this->_result.value());
825 
826  IDecomposer* argv[2] = { &_a1, &_a2 };
827  this->client().beginCall(this->_r, *this, argv, 2);
828  }
829 
830 #if __cplusplus >= 201103L
831  R&& call(const A1& a1, const A2& a2)
832 #else
833  R& call(const A1& a1, const A2& a2)
834 #endif
835  {
836  this->_result.clearFault();
837 
838  _a1.begin(a1);
839  _a2.begin(a2);
840  this->_r.begin(this->_result.value());
841 
842  IDecomposer* argv[2] = { &_a1, &_a2 };
843  this->client().call(this->_r, *this, argv, 2);
844  return this->_result.get();
845  }
846 
847 #if __cplusplus >= 201103L
848  R&& operator()(const A1& a1, const A2& a2)
849 #else
850  R& operator()(const A1& a1, const A2& a2)
851 #endif
852  {
853  return this->call(a1, a2);
854  }
855 
856  private:
857  Decomposer<A1> _a1;
858  Decomposer<A2> _a2;
859 };
860 
861 
862 template <typename R,
863  typename A1>
864 class RemoteProcedure<R, A1,
865  cxxtools::Void,
873  cxxtools::Void> : public RemoteProcedureBase<R>
874 {
875  public:
876  RemoteProcedure(RemoteClient& client, const String& name)
877  : RemoteProcedureBase<R>(client, name)
878  { }
879 
880  RemoteProcedure(RemoteClient& client, const char* name)
881  : RemoteProcedureBase<R>(client, String(name))
882  { }
883 
884  void begin(const A1& a1)
885  {
886  this->_result.clearFault();
887 
888  _a1.begin(a1);
889 
890  this->_r.begin(this->_result.value());
891 
892  IDecomposer* argv[1] = { &_a1 };
893  this->client().beginCall(this->_r, *this, argv, 1);
894  }
895 
896 #if __cplusplus >= 201103L
897  R&& call(const A1& a1)
898 #else
899  R& call(const A1& a1)
900 #endif
901  {
902  this->_result.clearFault();
903 
904  _a1.begin(a1);
905  this->_r.begin(this->_result.value());
906 
907  IDecomposer* argv[1] = { &_a1 };
908  this->client().call(this->_r, *this, argv, 1);
909  return this->_result.get();
910  }
911 
912 #if __cplusplus >= 201103L
913  R&& operator()(const A1& a1)
914 #else
915  R& operator()(const A1& a1)
916 #endif
917  {
918  return this->call(a1);
919  }
920 
921  private:
922  Decomposer<A1> _a1;
923 };
924 
925 
926 template <typename R>
927 class RemoteProcedure<R,
928  cxxtools::Void,
937  cxxtools::Void> : public RemoteProcedureBase<R>
938 {
939  public:
940  RemoteProcedure(RemoteClient& client, const String& name)
941  : RemoteProcedureBase<R>(client, name)
942  { }
943 
944  RemoteProcedure(RemoteClient& client, const char* name)
945  : RemoteProcedureBase<R>(client, String(name))
946  { }
947 
948  void begin()
949  {
950  this->_result.clearFault();
951 
952  this->_r.begin(this->_result.value());
953 
954  IDecomposer* argv[1] = { 0 };
955  this->client().beginCall(this->_r, *this, argv, 0);
956  }
957 
958 #if __cplusplus >= 201103L
959  R&& call()
960 #else
961  R& call()
962 #endif
963  {
964  this->_result.clearFault();
965 
966  this->_r.begin(this->_result.value());
967 
968  IDecomposer* argv[1] = { 0 };
969  this->client().call(this->_r, *this, argv, 0);
970  return this->_result.get();
971  }
972 
973 #if __cplusplus >= 201103L
974  R&& operator()()
975 #else
976  R& operator()()
977 #endif
978  {
979  return this->call();
980  }
981 };
982 
984 // end generated with `remoteprocedure.pl -n 10`
985 
986 }
987 
988 #endif