Main
Classes
Namespaces
Modules
BasicProcedure.h
1 /*
2  * Copyright (C) 2009-2014 by Marc Duerner
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 PT_REMOTING_BASICPROCEDURE_H
30 #define PT_REMOTING_BASICPROCEDURE_H
31 
32 #include <Pt/Remoting/Api.h>
33 #include <Pt/Remoting/ServiceProcedure.h>
34 #include <Pt/System/EventLoop.h>
35 #include <Pt/Decomposer.h>
36 #include <Pt/Composer.h>
37 #include <Pt/TypeTraits.h>
38 #include <Pt/Void.h>
39 
40 namespace Pt {
41 
42 namespace Remoting {
43 
44 class Responder;
45 
46 //
47 // BasicProcedure with 10 arguments
48 //
49 template < typename R,
50  typename A1 = Pt::Void,
51  typename A2 = Pt::Void,
52  typename A3 = Pt::Void,
53  typename A4 = Pt::Void,
54  typename A5 = Pt::Void,
55  typename A6 = Pt::Void,
56  typename A7 = Pt::Void,
57  typename A8 = Pt::Void,
58  typename A9 = Pt::Void,
59  typename A10 = Pt::Void>
60 class BasicProcedure : public ServiceProcedure
61 {
62  public:
63  BasicProcedure( const Callable<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& cb, Responder& resp)
64  : ServiceProcedure(resp)
65  , _cb(0)
66  , _a1(&resp.context())
67  , _a2(&resp.context())
68  , _a3(&resp.context())
69  , _a4(&resp.context())
70  , _a5(&resp.context())
71  , _a6(&resp.context())
72  , _a7(&resp.context())
73  , _a8(&resp.context())
74  , _a9(&resp.context())
75  , _a10(&resp.context())
76  , _r(&resp.context())
77  {
78  _cb = cb.clone();
79 
80  _args[0] = &_a1;
81  _args[1] = &_a2;
82  _args[2] = &_a3;
83  _args[3] = &_a4;
84  _args[4] = &_a5;
85  _args[5] = &_a6;
86  _args[6] = &_a7;
87  _args[7] = &_a8;
88  _args[8] = &_a9;
89  _args[9] = &_a10;
90  _args[10] = 0;
91  }
92 
93  ~BasicProcedure()
94  {
95  delete _cb;
96  }
97 
98  protected:
99  Composer** onBeginArgs()
100  {
101  _a1.begin(_v1);
102  _a2.begin(_v2);
103  _a3.begin(_v3);
104  _a4.begin(_v4);
105  _a5.begin(_v5);
106  _a6.begin(_v6);
107  _a7.begin(_v7);
108  _a8.begin(_v8);
109  _a9.begin(_v9);
110  _a10.begin(_v10);
111 
112  return _args;
113  }
114 
115  virtual void onBeginCall(System::EventLoop&)
116  {
117  this->setReady();
118  }
119 
120  Decomposer* onEndCall()
121  {
122  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5, _v6, _v7, _v8, _v9, _v10);
123  _r.begin(_rv, "");
124  return &_r;
125  }
126 
127  private:
128  typedef typename TypeTraits<A1>::Value V1;
129  typedef typename TypeTraits<A2>::Value V2;
130  typedef typename TypeTraits<A3>::Value V3;
131  typedef typename TypeTraits<A4>::Value V4;
132  typedef typename TypeTraits<A5>::Value V5;
133  typedef typename TypeTraits<A6>::Value V6;
134  typedef typename TypeTraits<A7>::Value V7;
135  typedef typename TypeTraits<A8>::Value V8;
136  typedef typename TypeTraits<A9>::Value V9;
137  typedef typename TypeTraits<A10>::Value V10;
138 
139  typedef typename TypeTraits<R>::Value RV;
140 
141  Callable<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>* _cb;
142  RV _rv;
143  V1 _v1;
144  V2 _v2;
145  V3 _v3;
146  V4 _v4;
147  V5 _v5;
148  V6 _v6;
149  V7 _v7;
150  V8 _v8;
151  V9 _v9;
152  V10 _v10;
153 
154  Composer* _args[11];
155  BasicComposer<V1> _a1;
156  BasicComposer<V2> _a2;
157  BasicComposer<V3> _a3;
158  BasicComposer<V4> _a4;
159  BasicComposer<V5> _a5;
160  BasicComposer<V6> _a6;
161  BasicComposer<V7> _a7;
162  BasicComposer<V8> _a8;
163  BasicComposer<V9> _a9;
164  BasicComposer<V10> _a10;
165  BasicDecomposer<RV> _r;
166 };
167 
168 
169 // BasicProcedure with 9 arguments
170 template < typename R,
171  typename A1,
172  typename A2,
173  typename A3,
174  typename A4,
175  typename A5,
176  typename A6,
177  typename A7,
178  typename A8,
179  typename A9>
180 class BasicProcedure<R, A1, A2, A3, A4, A5, A6, A7, A8, A9,
181  Pt::Void> : public ServiceProcedure
182 {
183  public:
184  BasicProcedure( const Callable<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>& cb, Responder& resp)
185  : ServiceProcedure(resp)
186  , _cb(0)
187  , _a1(&resp.context())
188  , _a2(&resp.context())
189  , _a3(&resp.context())
190  , _a4(&resp.context())
191  , _a5(&resp.context())
192  , _a6(&resp.context())
193  , _a7(&resp.context())
194  , _a8(&resp.context())
195  , _a9(&resp.context())
196  , _r(&resp.context())
197  {
198  _cb = cb.clone();
199 
200  _args[0] = &_a1;
201  _args[1] = &_a2;
202  _args[2] = &_a3;
203  _args[3] = &_a4;
204  _args[4] = &_a5;
205  _args[5] = &_a6;
206  _args[6] = &_a7;
207  _args[7] = &_a8;
208  _args[8] = &_a9;
209  _args[9] = 0;
210  }
211 
212  ~BasicProcedure()
213  {
214  delete _cb;
215  }
216 
217  protected:
218  Composer** onBeginArgs()
219  {
220  _a1.begin(_v1);
221  _a2.begin(_v2);
222  _a3.begin(_v3);
223  _a4.begin(_v4);
224  _a5.begin(_v5);
225  _a6.begin(_v6);
226  _a7.begin(_v7);
227  _a8.begin(_v8);
228  _a9.begin(_v9);
229 
230  return _args;
231  }
232 
233  virtual void onBeginCall(System::EventLoop&)
234  {
235  this->setReady();
236  }
237 
238  Decomposer* onEndCall()
239  {
240  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5, _v6, _v7, _v8, _v9);
241  _r.begin(_rv, "");
242  return &_r;
243  }
244 
245  private:
246  typedef typename TypeTraits<A1>::Value V1;
247  typedef typename TypeTraits<A2>::Value V2;
248  typedef typename TypeTraits<A3>::Value V3;
249  typedef typename TypeTraits<A4>::Value V4;
250  typedef typename TypeTraits<A5>::Value V5;
251  typedef typename TypeTraits<A6>::Value V6;
252  typedef typename TypeTraits<A7>::Value V7;
253  typedef typename TypeTraits<A8>::Value V8;
254  typedef typename TypeTraits<A9>::Value V9;
255 
256  typedef typename TypeTraits<R>::Value RV;
257 
258  Callable<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>* _cb;
259  RV _rv;
260  V1 _v1;
261  V2 _v2;
262  V3 _v3;
263  V4 _v4;
264  V5 _v5;
265  V6 _v6;
266  V7 _v7;
267  V8 _v8;
268  V9 _v9;
269 
270  Composer* _args[10];
271  BasicComposer<V1> _a1;
272  BasicComposer<V2> _a2;
273  BasicComposer<V3> _a3;
274  BasicComposer<V4> _a4;
275  BasicComposer<V5> _a5;
276  BasicComposer<V6> _a6;
277  BasicComposer<V7> _a7;
278  BasicComposer<V8> _a8;
279  BasicComposer<V9> _a9;
280  BasicDecomposer<RV> _r;
281 };
282 
283 
284 // BasicProcedure with 8 arguments
285 template < typename R,
286  typename A1,
287  typename A2,
288  typename A3,
289  typename A4,
290  typename A5,
291  typename A6,
292  typename A7,
293  typename A8>
294 class BasicProcedure<R, A1, A2, A3, A4, A5, A6, A7, A8,
295  Pt::Void,
296  Pt::Void> : public ServiceProcedure
297 {
298  public:
299  BasicProcedure( const Callable<R, A1, A2, A3, A4, A5, A6, A7, A8>& cb, Responder& resp)
300  : ServiceProcedure(resp)
301  , _cb(0)
302  , _a1(&resp.context())
303  , _a2(&resp.context())
304  , _a3(&resp.context())
305  , _a4(&resp.context())
306  , _a5(&resp.context())
307  , _a6(&resp.context())
308  , _a7(&resp.context())
309  , _a8(&resp.context())
310  , _r(&resp.context())
311  {
312  _cb = cb.clone();
313 
314  _args[0] = &_a1;
315  _args[1] = &_a2;
316  _args[2] = &_a3;
317  _args[3] = &_a4;
318  _args[4] = &_a5;
319  _args[5] = &_a6;
320  _args[6] = &_a7;
321  _args[7] = &_a8;
322  _args[8] = 0;
323  }
324 
325  ~BasicProcedure()
326  {
327  delete _cb;
328  }
329 
330  protected:
331  Composer** onBeginArgs()
332  {
333  _a1.begin(_v1);
334  _a2.begin(_v2);
335  _a3.begin(_v3);
336  _a4.begin(_v4);
337  _a5.begin(_v5);
338  _a6.begin(_v6);
339  _a7.begin(_v7);
340  _a8.begin(_v8);
341 
342  return _args;
343  }
344 
345  virtual void onBeginCall(System::EventLoop&)
346  {
347  this->setReady();
348  }
349 
350  Decomposer* onEndCall()
351  {
352  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5, _v6, _v7, _v8);
353  _r.begin(_rv, "");
354  return &_r;
355  }
356 
357  private:
358  typedef typename TypeTraits<A1>::Value V1;
359  typedef typename TypeTraits<A2>::Value V2;
360  typedef typename TypeTraits<A3>::Value V3;
361  typedef typename TypeTraits<A4>::Value V4;
362  typedef typename TypeTraits<A5>::Value V5;
363  typedef typename TypeTraits<A6>::Value V6;
364  typedef typename TypeTraits<A7>::Value V7;
365  typedef typename TypeTraits<A8>::Value V8;
366 
367  typedef typename TypeTraits<R>::Value RV;
368 
369  Callable<R, A1, A2, A3, A4, A5, A6, A7, A8>* _cb;
370  RV _rv;
371  V1 _v1;
372  V2 _v2;
373  V3 _v3;
374  V4 _v4;
375  V5 _v5;
376  V6 _v6;
377  V7 _v7;
378  V8 _v8;
379 
380  Composer* _args[9];
381  BasicComposer<V1> _a1;
382  BasicComposer<V2> _a2;
383  BasicComposer<V3> _a3;
384  BasicComposer<V4> _a4;
385  BasicComposer<V5> _a5;
386  BasicComposer<V6> _a6;
387  BasicComposer<V7> _a7;
388  BasicComposer<V8> _a8;
389  BasicDecomposer<RV> _r;
390 };
391 
392 
393 // BasicProcedure with 7 arguments
394 template < typename R,
395  typename A1,
396  typename A2,
397  typename A3,
398  typename A4,
399  typename A5,
400  typename A6,
401  typename A7>
402 class BasicProcedure<R, A1, A2, A3, A4, A5, A6, A7,
403  Pt::Void,
404  Pt::Void,
405  Pt::Void> : public ServiceProcedure
406 {
407  public:
408  BasicProcedure( const Callable<R, A1, A2, A3, A4, A5, A6, A7>& cb, Responder& resp)
409  : ServiceProcedure(resp)
410  , _cb(0)
411  , _a1(&resp.context())
412  , _a2(&resp.context())
413  , _a3(&resp.context())
414  , _a4(&resp.context())
415  , _a5(&resp.context())
416  , _a6(&resp.context())
417  , _a7(&resp.context())
418  , _r(&resp.context())
419  {
420  _cb = cb.clone();
421 
422  _args[0] = &_a1;
423  _args[1] = &_a2;
424  _args[2] = &_a3;
425  _args[3] = &_a4;
426  _args[4] = &_a5;
427  _args[5] = &_a6;
428  _args[6] = &_a7;
429  _args[7] = 0;
430  }
431 
432  ~BasicProcedure()
433  {
434  delete _cb;
435  }
436 
437  protected:
438  Composer** onBeginArgs()
439  {
440  _a1.begin(_v1);
441  _a2.begin(_v2);
442  _a3.begin(_v3);
443  _a4.begin(_v4);
444  _a5.begin(_v5);
445  _a6.begin(_v6);
446  _a7.begin(_v7);
447 
448  return _args;
449  }
450 
451  virtual void onBeginCall(System::EventLoop&)
452  {
453  this->setReady();
454  }
455 
456  Decomposer* onEndCall()
457  {
458  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5, _v6, _v7);
459  _r.begin(_rv, "");
460  return &_r;
461  }
462 
463  private:
464  typedef typename TypeTraits<A1>::Value V1;
465  typedef typename TypeTraits<A2>::Value V2;
466  typedef typename TypeTraits<A3>::Value V3;
467  typedef typename TypeTraits<A4>::Value V4;
468  typedef typename TypeTraits<A5>::Value V5;
469  typedef typename TypeTraits<A6>::Value V6;
470  typedef typename TypeTraits<A7>::Value V7;
471 
472  typedef typename TypeTraits<R>::Value RV;
473 
474  Callable<R, A1, A2, A3, A4, A5, A6, A7>* _cb;
475  RV _rv;
476  V1 _v1;
477  V2 _v2;
478  V3 _v3;
479  V4 _v4;
480  V5 _v5;
481  V6 _v6;
482  V7 _v7;
483 
484  Composer* _args[8];
485  BasicComposer<V1> _a1;
486  BasicComposer<V2> _a2;
487  BasicComposer<V3> _a3;
488  BasicComposer<V4> _a4;
489  BasicComposer<V5> _a5;
490  BasicComposer<V6> _a6;
491  BasicComposer<V7> _a7;
492  BasicDecomposer<RV> _r;
493 };
494 
495 
496 // BasicProcedure with 6 arguments
497 template < typename R,
498  typename A1,
499  typename A2,
500  typename A3,
501  typename A4,
502  typename A5,
503  typename A6>
504 class BasicProcedure<R, A1, A2, A3, A4, A5, A6,
505  Pt::Void,
506  Pt::Void,
507  Pt::Void,
508  Pt::Void> : public ServiceProcedure
509 {
510  public:
511  BasicProcedure( const Callable<R, A1, A2, A3, A4, A5, A6>& cb, Responder& resp)
512  : ServiceProcedure(resp)
513  , _cb(0)
514  , _a1(&resp.context())
515  , _a2(&resp.context())
516  , _a3(&resp.context())
517  , _a4(&resp.context())
518  , _a5(&resp.context())
519  , _a6(&resp.context())
520  , _r(&resp.context())
521  {
522  _cb = cb.clone();
523 
524  _args[0] = &_a1;
525  _args[1] = &_a2;
526  _args[2] = &_a3;
527  _args[3] = &_a4;
528  _args[4] = &_a5;
529  _args[5] = &_a6;
530  _args[6] = 0;
531  }
532 
533  ~BasicProcedure()
534  {
535  delete _cb;
536  }
537 
538  protected:
539  Composer** onBeginArgs()
540  {
541  _a1.begin(_v1);
542  _a2.begin(_v2);
543  _a3.begin(_v3);
544  _a4.begin(_v4);
545  _a5.begin(_v5);
546  _a6.begin(_v6);
547 
548  return _args;
549  }
550 
551  virtual void onBeginCall(System::EventLoop&)
552  {
553  this->setReady();
554  }
555 
556  Decomposer* onEndCall()
557  {
558  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5, _v6);
559  _r.begin(_rv, "");
560  return &_r;
561  }
562 
563  private:
564  typedef typename TypeTraits<A1>::Value V1;
565  typedef typename TypeTraits<A2>::Value V2;
566  typedef typename TypeTraits<A3>::Value V3;
567  typedef typename TypeTraits<A4>::Value V4;
568  typedef typename TypeTraits<A5>::Value V5;
569  typedef typename TypeTraits<A6>::Value V6;
570 
571  typedef typename TypeTraits<R>::Value RV;
572 
573  Callable<R, A1, A2, A3, A4, A5, A6>* _cb;
574  RV _rv;
575  V1 _v1;
576  V2 _v2;
577  V3 _v3;
578  V4 _v4;
579  V5 _v5;
580  V6 _v6;
581 
582  Composer* _args[7];
583  BasicComposer<V1> _a1;
584  BasicComposer<V2> _a2;
585  BasicComposer<V3> _a3;
586  BasicComposer<V4> _a4;
587  BasicComposer<V5> _a5;
588  BasicComposer<V6> _a6;
589  BasicDecomposer<RV> _r;
590 };
591 
592 
593 // BasicProcedure with 5 arguments
594 template < typename R,
595  typename A1,
596  typename A2,
597  typename A3,
598  typename A4,
599  typename A5>
600 class BasicProcedure<R, A1, A2, A3, A4, A5,
601  Pt::Void,
602  Pt::Void,
603  Pt::Void,
604  Pt::Void,
605  Pt::Void> : public ServiceProcedure
606 {
607  public:
608  BasicProcedure( const Callable<R, A1, A2, A3, A4, A5>& cb, Responder& resp)
609  : ServiceProcedure(resp)
610  , _cb(0)
611  , _a1(&resp.context())
612  , _a2(&resp.context())
613  , _a3(&resp.context())
614  , _a4(&resp.context())
615  , _a5(&resp.context())
616  , _r(&resp.context())
617  {
618  _cb = cb.clone();
619 
620  _args[0] = &_a1;
621  _args[1] = &_a2;
622  _args[2] = &_a3;
623  _args[3] = &_a4;
624  _args[4] = &_a5;
625  _args[5] = 0;
626  }
627 
628  ~BasicProcedure()
629  {
630  delete _cb;
631  }
632 
633  protected:
634  Composer** onBeginArgs()
635  {
636  _a1.begin(_v1);
637  _a2.begin(_v2);
638  _a3.begin(_v3);
639  _a4.begin(_v4);
640  _a5.begin(_v5);
641 
642  return _args;
643  }
644 
645  virtual void onBeginCall(System::EventLoop&)
646  {
647  this->setReady();
648  }
649 
650  Decomposer* onEndCall()
651  {
652  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5);
653  _r.begin(_rv, "");
654  return &_r;
655  }
656 
657  private:
658  typedef typename TypeTraits<A1>::Value V1;
659  typedef typename TypeTraits<A2>::Value V2;
660  typedef typename TypeTraits<A3>::Value V3;
661  typedef typename TypeTraits<A4>::Value V4;
662  typedef typename TypeTraits<A5>::Value V5;
663 
664  typedef typename TypeTraits<R>::Value RV;
665 
666  Callable<R, A1, A2, A3, A4, A5>* _cb;
667  RV _rv;
668  V1 _v1;
669  V2 _v2;
670  V3 _v3;
671  V4 _v4;
672  V5 _v5;
673 
674  Composer* _args[6];
675  BasicComposer<V1> _a1;
676  BasicComposer<V2> _a2;
677  BasicComposer<V3> _a3;
678  BasicComposer<V4> _a4;
679  BasicComposer<V5> _a5;
680  BasicDecomposer<RV> _r;
681 };
682 
683 
684 // BasicProcedure with 4 arguments
685 template < typename R,
686  typename A1,
687  typename A2,
688  typename A3,
689  typename A4>
690 class BasicProcedure<R, A1, A2, A3, A4,
691  Pt::Void,
692  Pt::Void,
693  Pt::Void,
694  Pt::Void,
695  Pt::Void,
696  Pt::Void> : public ServiceProcedure
697 {
698  public:
699  BasicProcedure( const Callable<R, A1, A2, A3, A4>& cb, Responder& resp)
700  : ServiceProcedure(resp)
701  , _cb(0)
702  , _a1(&resp.context())
703  , _a2(&resp.context())
704  , _a3(&resp.context())
705  , _a4(&resp.context())
706  , _r(&resp.context())
707  {
708  _cb = cb.clone();
709 
710  _args[0] = &_a1;
711  _args[1] = &_a2;
712  _args[2] = &_a3;
713  _args[3] = &_a4;
714  _args[4] = 0;
715  }
716 
717  ~BasicProcedure()
718  {
719  delete _cb;
720  }
721 
722  protected:
723  Composer** onBeginArgs()
724  {
725  _a1.begin(_v1);
726  _a2.begin(_v2);
727  _a3.begin(_v3);
728  _a4.begin(_v4);
729 
730  return _args;
731  }
732 
733  virtual void onBeginCall(System::EventLoop&)
734  {
735  this->setReady();
736  }
737 
738  Decomposer* onEndCall()
739  {
740  _rv = _cb->call(_v1, _v2, _v3, _v4);
741  _r.begin(_rv, "");
742  return &_r;
743  }
744 
745  private:
746  typedef typename TypeTraits<A1>::Value V1;
747  typedef typename TypeTraits<A2>::Value V2;
748  typedef typename TypeTraits<A3>::Value V3;
749  typedef typename TypeTraits<A4>::Value V4;
750 
751  typedef typename TypeTraits<R>::Value RV;
752 
753  Callable<R, A1, A2, A3, A4>* _cb;
754  RV _rv;
755  V1 _v1;
756  V2 _v2;
757  V3 _v3;
758  V4 _v4;
759 
760  Composer* _args[5];
761  BasicComposer<V1> _a1;
762  BasicComposer<V2> _a2;
763  BasicComposer<V3> _a3;
764  BasicComposer<V4> _a4;
765  BasicDecomposer<RV> _r;
766 };
767 
768 
769 // BasicProcedure with 3 arguments
770 template < typename R,
771  typename A1,
772  typename A2,
773  typename A3>
774 class BasicProcedure<R, A1, A2, A3,
775  Pt::Void,
776  Pt::Void,
777  Pt::Void,
778  Pt::Void,
779  Pt::Void,
780  Pt::Void,
781  Pt::Void> : public ServiceProcedure
782 {
783  public:
784  BasicProcedure( const Callable<R, A1, A2, A3>& cb, Responder& resp )
785  : ServiceProcedure(resp)
786  , _cb(0)
787  , _a1(&resp.context())
788  , _a2(&resp.context())
789  , _a3(&resp.context())
790  , _r(&resp.context())
791  {
792  _cb = cb.clone();
793 
794  _args[0] = &_a1;
795  _args[1] = &_a2;
796  _args[2] = &_a3;
797  _args[3] = 0;
798  }
799 
800  ~BasicProcedure()
801  {
802  delete _cb;
803  }
804 
805  protected:
806  Composer** onBeginArgs()
807  {
808  _a1.begin(_v1);
809  _a2.begin(_v2);
810  _a3.begin(_v3);
811 
812  return _args;
813  }
814 
815  virtual void onBeginCall(System::EventLoop&)
816  {
817  this->setReady();
818  }
819 
820  Decomposer* onEndCall()
821  {
822  _rv = _cb->call(_v1, _v2, _v3);
823  _r.begin(_rv, "");
824  return &_r;
825  }
826 
827  private:
828  typedef typename TypeTraits<A1>::Value V1;
829  typedef typename TypeTraits<A2>::Value V2;
830  typedef typename TypeTraits<A3>::Value V3;
831 
832  typedef typename TypeTraits<R>::Value RV;
833 
834  Callable<R, A1, A2, A3>* _cb;
835  RV _rv;
836  V1 _v1;
837  V2 _v2;
838  V3 _v3;
839 
840  Composer* _args[4];
841  BasicComposer<V1> _a1;
842  BasicComposer<V2> _a2;
843  BasicComposer<V3> _a3;
844  BasicDecomposer<RV> _r;
845 };
846 
847 
848 // BasicProcedure with 2 arguments
849 template < typename R,
850  typename A1,
851  typename A2>
852 class BasicProcedure<R, A1, A2,
853  Pt::Void,
854  Pt::Void,
855  Pt::Void,
856  Pt::Void,
857  Pt::Void,
858  Pt::Void,
859  Pt::Void,
860  Pt::Void> : public ServiceProcedure
861 {
862  public:
863  BasicProcedure( const Callable<R, A1, A2>& cb, Responder& resp )
864  : ServiceProcedure(resp)
865  , _cb(0)
866  , _a1(&resp.context())
867  , _a2(&resp.context())
868  , _r(&resp.context())
869  {
870  _cb = cb.clone();
871 
872  _args[0] = &_a1;
873  _args[1] = &_a2;
874  _args[2] = 0;
875  }
876 
877  ~BasicProcedure()
878  {
879  delete _cb;
880  }
881 
882  protected:
883  Composer** onBeginArgs()
884  {
885  _a1.begin(_v1);
886  _a2.begin(_v2);
887 
888  return _args;
889  }
890 
891  virtual void onBeginCall(System::EventLoop&)
892  {
893  this->setReady();
894  }
895 
896  Decomposer* onEndCall()
897  {
898  _rv = _cb->call(_v1, _v2);
899  _r.begin(_rv, "");
900  return &_r;
901  }
902 
903  private:
904  typedef typename TypeTraits<A1>::Value V1;
905  typedef typename TypeTraits<A2>::Value V2;
906 
907  typedef typename TypeTraits<R>::Value RV;
908 
909  Callable<R, A1, A2>* _cb;
910  RV _rv;
911  V1 _v1;
912  V2 _v2;
913 
914  Composer* _args[3];
915  BasicComposer<V1> _a1;
916  BasicComposer<V2> _a2;
917  BasicDecomposer<RV> _r;
918 };
919 
920 
921 // BasicProcedure with 1 arguments
922 template < typename R,
923  typename A1>
924 class BasicProcedure<R, A1,
925  Pt::Void,
926  Pt::Void,
927  Pt::Void,
928  Pt::Void,
929  Pt::Void,
930  Pt::Void,
931  Pt::Void,
932  Pt::Void,
933  Pt::Void> : public ServiceProcedure
934 {
935  public:
936  BasicProcedure( const Callable<R, A1>& cb, Responder& resp)
937  : ServiceProcedure(resp)
938  , _cb(0)
939  , _a1(&resp.context())
940  , _r(&resp.context())
941  {
942  _cb = cb.clone();
943 
944  _args[0] = &_a1;
945  _args[1] = 0;
946  }
947 
948  ~BasicProcedure()
949  {
950  delete _cb;
951  }
952 
953  protected:
954  Composer** onBeginArgs()
955  {
956  _a1.begin(_v1);
957 
958  return _args;
959  }
960 
961  virtual void onBeginCall(System::EventLoop&)
962  {
963  this->setReady();
964  }
965 
966  Decomposer* onEndCall()
967  {
968  _rv = _cb->call(_v1);
969  _r.begin(_rv, "");
970  return &_r;
971  }
972 
973  private:
974  typedef typename TypeTraits<A1>::Value V1;
975  typedef typename TypeTraits<R>::Value RV;
976 
977  Callable<R, A1>* _cb;
978  RV _rv;
979  V1 _v1;
980 
981  Composer* _args[2];
982  BasicComposer<V1> _a1;
983  BasicDecomposer<RV> _r;
984 };
985 
986 
987 //
988 // BasicProcedure with 0 arguments
989 //
990 
991 template < typename R>
992 class BasicProcedure<R,
993  Pt::Void,
994  Pt::Void,
995  Pt::Void,
996  Pt::Void,
997  Pt::Void,
998  Pt::Void,
999  Pt::Void,
1000  Pt::Void,
1001  Pt::Void,
1002  Pt::Void> : public ServiceProcedure
1003 {
1004  public:
1005  BasicProcedure(const Callable<R>& cb, Responder& resp)
1006  : ServiceProcedure(resp)
1007  , _cb(0)
1008  , _r(&resp.context())
1009  {
1010  _cb = cb.clone();
1011 
1012  _args[0] = 0;
1013  }
1014 
1015  ~BasicProcedure()
1016  {
1017  delete _cb;
1018  }
1019 
1020  protected:
1021  Composer** onBeginArgs()
1022  {
1023  return _args;
1024  }
1025 
1026  virtual void onBeginCall(System::EventLoop&)
1027  {
1028  this->setReady();
1029  }
1030 
1031  Decomposer* onEndCall()
1032  {
1033  _rv = _cb->call();
1034  _r.begin(_rv, "");
1035  return &_r;
1036  }
1037 
1038  private:
1039  typedef typename TypeTraits<R>::Value RV;
1040 
1041  Callable<R>* _cb;
1042  RV _rv;
1043 
1044  Composer* _args[1];
1045  BasicDecomposer<RV> _r;
1046 };
1047 
1048 
1049 template < typename R,
1050  typename A1 = Pt::Void,
1051  typename A2 = Pt::Void,
1052  typename A3 = Pt::Void,
1053  typename A4 = Pt::Void,
1054  typename A5 = Pt::Void,
1055  typename A6 = Pt::Void,
1056  typename A7 = Pt::Void,
1057  typename A8 = Pt::Void,
1058  typename A9 = Pt::Void,
1059  typename A10 = Pt::Void >
1060 class BasicProcedureDef : public ServiceProcedureDef
1061 {
1062  public:
1063  BasicProcedureDef(const Callable<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& cb)
1064  : _cb(0)
1065  {
1066  _cb = cb.clone();
1067  }
1068 
1069  ~BasicProcedureDef()
1070  {
1071  delete _cb;
1072  }
1073 
1074  protected:
1075  virtual ServiceProcedure* onCreateProcedure(Responder& resp) const
1076  {
1077  return new BasicProcedure<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>( *_cb, resp );
1078  }
1079 
1080  private:
1081  Callable<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>* _cb;
1082 };
1083 
1084 } // namespace Remoting
1085 
1086 } // namespace Pt
1087 
1088 #endif // PT_REMOTING_BASICPROCEDURE_H
Pt::Remoting::ServiceProcedure::ServiceProcedure
ServiceProcedure(Responder &r)
Constructor.
Definition: ServiceProcedure.h:72
Pt::TypeTraits< A1 >::Value
IMPLEMENTATION_DEFINED Value
The derived value type.
Definition: TypeTraits.h:21
Pt::Remoting::ServiceProcedure::setReady
void setReady()
Indicates that the procedure has finished.
Definition: ServiceProcedure.h:54
Pt::Void
Void type.
Definition: Void.h:43