Main
Classes
Namespaces
Modules
ActiveProcedure.h
1 /*
2  * Copyright (C) 209-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_ACTIVEPROCEDURE_H
30 #define PT_REMOTING_ACTIVEPROCEDURE_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/Void.h>
38 
39 namespace Pt {
40 
41 namespace Remoting {
42 
43 class Responder;
44 
45 template < typename R,
46  typename A1 = Pt::Void,
47  typename A2 = Pt::Void,
48  typename A3 = Pt::Void,
49  typename A4 = Pt::Void,
50  typename A5 = Pt::Void,
51  typename A6 = Pt::Void,
52  typename A7 = Pt::Void,
53  typename A8 = Pt::Void,
54  typename A9 = Pt::Void,
55  typename A10 = Pt::Void>
56 class ActiveProcedure : public ServiceProcedure
57 {
58  public:
59  typedef R ReturnT;
60  typedef A1 Arg1T;
61  typedef A2 Arg2T;
62  typedef A3 Arg3T;
63  typedef A4 Arg4T;
64  typedef A5 Arg5T;
65  typedef A6 Arg6T;
66  typedef A7 Arg7T;
67  typedef A8 Arg8T;
68  typedef A9 Arg9T;
69  typedef A10 Arg10T;
70 
71  public:
72  ActiveProcedure(Responder& resp)
73  : ServiceProcedure(resp)
74  , _a1(&resp.context())
75  , _a2(&resp.context())
76  , _a3(&resp.context())
77  , _a4(&resp.context())
78  , _a5(&resp.context())
79  , _a6(&resp.context())
80  , _a7(&resp.context())
81  , _a8(&resp.context())
82  , _a9(&resp.context())
83  , _a10(&resp.context())
84  , _r(&resp.context())
85  {
86  _args[0] = &_a1;
87  _args[1] = &_a2;
88  _args[2] = &_a3;
89  _args[3] = &_a4;
90  _args[4] = &_a5;
91  _args[5] = &_a6;
92  _args[6] = &_a7;
93  _args[7] = &_a8;
94  _args[8] = &_a9;
95  _args[9] = &_a10;
96  _args[10] = 0;
97  }
98 
99  protected:
100  Composer** onBeginArgs()
101  {
102  _a1.begin(_v1);
103  _a2.begin(_v2);
104  _a3.begin(_v3);
105  _a4.begin(_v4);
106  _a5.begin(_v5);
107  _a6.begin(_v6);
108  _a7.begin(_v7);
109  _a8.begin(_v8);
110  _a9.begin(_v9);
111  _a10.begin(_v10);
112 
113  return _args;
114  }
115 
116  virtual void onBeginCall(System::EventLoop& loop)
117  {
118  onInvoke(loop, _v1, _v2, _v3, _v4, _v5, _v6, _v7, _v8, _v9, _v10);
119  }
120 
121  Decomposer* onEndCall()
122  {
123  const R& r = onResult();
124  _r.begin(r, "");
125  return &_r;
126  }
127 
128  protected:
129  virtual void onInvoke(System::EventLoop& loop,
130  const A1& a1, const A2& a2,
131  const A3& a3, const A4& a4,
132  const A5& a5, const A6& a6,
133  const A7& a7, const A8& a8,
134  const A9& a9, const A10& a10) = 0;
135 
136  virtual const R& onResult() = 0;
137 
138  private:
139  A1 _v1;
140  A2 _v2;
141  A3 _v3;
142  A4 _v4;
143  A5 _v5;
144  A6 _v6;
145  A7 _v7;
146  A8 _v8;
147  A9 _v9;
148  A10 _v10;
149 
150  Composer* _args[11];
151  BasicComposer<A1> _a1;
152  BasicComposer<A2> _a2;
153  BasicComposer<A3> _a3;
154  BasicComposer<A4> _a4;
155  BasicComposer<A5> _a5;
156  BasicComposer<A6> _a6;
157  BasicComposer<A7> _a7;
158  BasicComposer<A8> _a8;
159  BasicComposer<A9> _a9;
160  BasicComposer<A10> _a10;
161  BasicDecomposer<R> _r;
162 };
163 
164 
165 template < typename R,
166  typename A1,
167  typename A2,
168  typename A3,
169  typename A4,
170  typename A5,
171  typename A6,
172  typename A7,
173  typename A8,
174  typename A9>
175 class ActiveProcedure<R, A1, A2, A3, A4, A5, A6, A7, A8, A9,
176  Pt::Void> : public ServiceProcedure
177 {
178  public:
179  typedef R ReturnT;
180  typedef A1 Arg1T;
181  typedef A2 Arg2T;
182  typedef A3 Arg3T;
183  typedef A4 Arg4T;
184  typedef A5 Arg5T;
185  typedef A6 Arg6T;
186  typedef A7 Arg7T;
187  typedef A8 Arg8T;
188  typedef A9 Arg9T;
189  typedef Void Arg10T;
190 
191  public:
192  ActiveProcedure(Responder& resp)
193  : ServiceProcedure(resp)
194  , _a1(&resp.context())
195  , _a2(&resp.context())
196  , _a3(&resp.context())
197  , _a4(&resp.context())
198  , _a5(&resp.context())
199  , _a6(&resp.context())
200  , _a7(&resp.context())
201  , _a8(&resp.context())
202  , _a9(&resp.context())
203  , _r(&resp.context())
204  {
205  _args[0] = &_a1;
206  _args[1] = &_a2;
207  _args[2] = &_a3;
208  _args[3] = &_a4;
209  _args[4] = &_a5;
210  _args[5] = &_a6;
211  _args[6] = &_a7;
212  _args[7] = &_a8;
213  _args[8] = &_a9;
214  _args[9] = 0;
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& loop)
234  {
235  onInvoke(loop, _v1, _v2, _v3, _v4, _v5, _v6, _v7, _v8, _v9);
236  }
237 
238  Decomposer* onEndCall()
239  {
240  const R& r = onResult();
241  _r.begin(r, "");
242  return &_r;
243  }
244 
245  protected:
246  virtual void onInvoke(System::EventLoop& loop,
247  const A1& a1, const A2& a2,
248  const A3& a3, const A4& a4,
249  const A5& a5, const A6& a6,
250  const A7& a7, const A8& a8,
251  const A9& a9) = 0;
252 
253  virtual const R& onResult() = 0;
254 
255  private:
256  A1 _v1;
257  A2 _v2;
258  A3 _v3;
259  A4 _v4;
260  A5 _v5;
261  A6 _v6;
262  A7 _v7;
263  A8 _v8;
264  A9 _v9;
265 
266  Composer* _args[10];
267  BasicComposer<A1> _a1;
268  BasicComposer<A2> _a2;
269  BasicComposer<A3> _a3;
270  BasicComposer<A4> _a4;
271  BasicComposer<A5> _a5;
272  BasicComposer<A6> _a6;
273  BasicComposer<A7> _a7;
274  BasicComposer<A8> _a8;
275  BasicComposer<A9> _a9;
276  BasicDecomposer<R> _r;
277 };
278 
279 
280 template < typename R,
281  typename A1,
282  typename A2,
283  typename A3,
284  typename A4,
285  typename A5,
286  typename A6,
287  typename A7,
288  typename A8>
289 class ActiveProcedure<R, A1, A2, A3, A4, A5, A6, A7, A8,
290  Pt::Void,
291  Pt::Void> : public ServiceProcedure
292 {
293  public:
294  typedef R ReturnT;
295  typedef A1 Arg1T;
296  typedef A2 Arg2T;
297  typedef A3 Arg3T;
298  typedef A4 Arg4T;
299  typedef A5 Arg5T;
300  typedef A6 Arg6T;
301  typedef A7 Arg7T;
302  typedef A8 Arg8T;
303  typedef Void Arg9T;
304  typedef Void Arg10T;
305 
306  public:
307  ActiveProcedure(Responder& resp)
308  : ServiceProcedure(resp)
309  , _a1(&resp.context())
310  , _a2(&resp.context())
311  , _a3(&resp.context())
312  , _a4(&resp.context())
313  , _a5(&resp.context())
314  , _a6(&resp.context())
315  , _a7(&resp.context())
316  , _a8(&resp.context())
317  , _r(&resp.context())
318  {
319  _args[0] = &_a1;
320  _args[1] = &_a2;
321  _args[2] = &_a3;
322  _args[3] = &_a4;
323  _args[4] = &_a5;
324  _args[5] = &_a6;
325  _args[6] = &_a7;
326  _args[7] = &_a8;
327  _args[8] = 0;
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& loop)
346  {
347  onInvoke(loop, _v1, _v2, _v3, _v4, _v5, _v6, _v7, _v8);
348  }
349 
350  Decomposer* onEndCall()
351  {
352  const R& r = onResult();
353  _r.begin(r, "");
354  return &_r;
355  }
356 
357  protected:
358  virtual void onInvoke(System::EventLoop& loop,
359  const A1& a1, const A2& a2,
360  const A3& a3, const A4& a4,
361  const A5& a5, const A6& a6,
362  const A7& a7, const A8& a8) = 0;
363 
364  virtual const R& onResult() = 0;
365 
366  private:
367  A1 _v1;
368  A2 _v2;
369  A3 _v3;
370  A4 _v4;
371  A5 _v5;
372  A6 _v6;
373  A7 _v7;
374  A8 _v8;
375 
376  Composer* _args[9];
377  BasicComposer<A1> _a1;
378  BasicComposer<A2> _a2;
379  BasicComposer<A3> _a3;
380  BasicComposer<A4> _a4;
381  BasicComposer<A5> _a5;
382  BasicComposer<A6> _a6;
383  BasicComposer<A7> _a7;
384  BasicComposer<A8> _a8;
385  BasicDecomposer<R> _r;
386 };
387 
388 
389 template < typename R,
390  typename A1,
391  typename A2,
392  typename A3,
393  typename A4,
394  typename A5,
395  typename A6,
396  typename A7>
397 class ActiveProcedure<R, A1, A2, A3, A4, A5, A6, A7,
398  Pt::Void,
399  Pt::Void,
400  Pt::Void> : public ServiceProcedure
401 {
402  public:
403  typedef R ReturnT;
404  typedef A1 Arg1T;
405  typedef A2 Arg2T;
406  typedef A3 Arg3T;
407  typedef A4 Arg4T;
408  typedef A5 Arg5T;
409  typedef A6 Arg6T;
410  typedef A7 Arg7T;
411  typedef Void Arg8T;
412  typedef Void Arg9T;
413  typedef Void Arg10T;
414 
415  public:
416  ActiveProcedure(Responder& resp)
417  : ServiceProcedure(resp)
418  , _a1(&resp.context())
419  , _a2(&resp.context())
420  , _a3(&resp.context())
421  , _a4(&resp.context())
422  , _a5(&resp.context())
423  , _a6(&resp.context())
424  , _a7(&resp.context())
425  , _r(&resp.context())
426  {
427  _args[0] = &_a1;
428  _args[1] = &_a2;
429  _args[2] = &_a3;
430  _args[3] = &_a4;
431  _args[4] = &_a5;
432  _args[5] = &_a6;
433  _args[6] = &_a7;
434  _args[7] = 0;
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& loop)
452  {
453  onInvoke(loop, _v1, _v2, _v3, _v4, _v5, _v6, _v7);
454  }
455 
456  Decomposer* onEndCall()
457  {
458  const R& r = onResult();
459  _r.begin(r, "");
460  return &_r;
461  }
462 
463  protected:
464  virtual void onInvoke(System::EventLoop& loop,
465  const A1& a1, const A2& a2,
466  const A3& a3, const A4& a4,
467  const A5& a5, const A6& a6,
468  const A7& a7) = 0;
469 
470  virtual const R& onResult() = 0;
471 
472  private:
473  A1 _v1;
474  A2 _v2;
475  A3 _v3;
476  A4 _v4;
477  A5 _v5;
478  A6 _v6;
479  A7 _v7;
480 
481  Composer* _args[8];
482  BasicComposer<A1> _a1;
483  BasicComposer<A2> _a2;
484  BasicComposer<A3> _a3;
485  BasicComposer<A4> _a4;
486  BasicComposer<A5> _a5;
487  BasicComposer<A6> _a6;
488  BasicComposer<A7> _a7;
489  BasicDecomposer<R> _r;
490 };
491 
492 
493 template < typename R,
494  typename A1,
495  typename A2,
496  typename A3,
497  typename A4,
498  typename A5,
499  typename A6>
500 class ActiveProcedure<R, A1, A2, A3, A4, A5, A6,
501  Pt::Void,
502  Pt::Void,
503  Pt::Void,
504  Pt::Void> : public ServiceProcedure
505 {
506  public:
507  typedef R ReturnT;
508  typedef A1 Arg1T;
509  typedef A2 Arg2T;
510  typedef A3 Arg3T;
511  typedef A4 Arg4T;
512  typedef A5 Arg5T;
513  typedef A6 Arg6T;
514  typedef Void Arg7T;
515  typedef Void Arg8T;
516  typedef Void Arg9T;
517  typedef Void Arg10T;
518 
519  public:
520  ActiveProcedure(Responder& resp)
521  : ServiceProcedure(resp)
522  , _a1(&resp.context())
523  , _a2(&resp.context())
524  , _a3(&resp.context())
525  , _a4(&resp.context())
526  , _a5(&resp.context())
527  , _a6(&resp.context())
528  , _r(&resp.context())
529  {
530  _args[0] = &_a1;
531  _args[1] = &_a2;
532  _args[2] = &_a3;
533  _args[3] = &_a4;
534  _args[4] = &_a5;
535  _args[5] = &_a6;
536  _args[6] = 0;
537  }
538 
539  protected:
540  Composer** onBeginArgs()
541  {
542  _a1.begin(_v1);
543  _a2.begin(_v2);
544  _a3.begin(_v3);
545  _a4.begin(_v4);
546  _a5.begin(_v5);
547  _a6.begin(_v6);
548 
549  return _args;
550  }
551 
552  virtual void onBeginCall(System::EventLoop& loop)
553  {
554  onInvoke(loop, _v1, _v2, _v3, _v4, _v5, _v6);
555  }
556 
557  Decomposer* onEndCall()
558  {
559  const R& r = onResult();
560  _r.begin(r, "");
561  return &_r;
562  }
563 
564  protected:
565  virtual void onInvoke(System::EventLoop& loop,
566  const A1& a1, const A2& a2,
567  const A3& a3, const A4& a4,
568  const A5& a5, const A6& a6) = 0;
569 
570  virtual const R& onResult() = 0;
571 
572  private:
573  A1 _v1;
574  A2 _v2;
575  A3 _v3;
576  A4 _v4;
577  A5 _v5;
578  A6 _v6;
579 
580  Composer* _args[7];
581  BasicComposer<A1> _a1;
582  BasicComposer<A2> _a2;
583  BasicComposer<A3> _a3;
584  BasicComposer<A4> _a4;
585  BasicComposer<A5> _a5;
586  BasicComposer<A6> _a6;
587  BasicDecomposer<R> _r;
588 };
589 
590 
591 template < typename R,
592  typename A1,
593  typename A2,
594  typename A3,
595  typename A4,
596  typename A5>
597 class ActiveProcedure<R, A1, A2, A3, A4, A5,
598  Pt::Void,
599  Pt::Void,
600  Pt::Void,
601  Pt::Void,
602  Pt::Void> : public ServiceProcedure
603 {
604  public:
605  typedef R ReturnT;
606  typedef A1 Arg1T;
607  typedef A2 Arg2T;
608  typedef A3 Arg3T;
609  typedef A4 Arg4T;
610  typedef A5 Arg5T;
611  typedef Void Arg6T;
612  typedef Void Arg7T;
613  typedef Void Arg8T;
614  typedef Void Arg9T;
615  typedef Void Arg10T;
616 
617  public:
618  ActiveProcedure(Responder& resp)
619  : ServiceProcedure(resp)
620  , _a1(&resp.context())
621  , _a2(&resp.context())
622  , _a3(&resp.context())
623  , _a4(&resp.context())
624  , _a5(&resp.context())
625  , _r(&resp.context())
626  {
627  _args[0] = &_a1;
628  _args[1] = &_a2;
629  _args[2] = &_a3;
630  _args[3] = &_a4;
631  _args[4] = &_a5;
632  _args[5] = 0;
633  }
634 
635  A1& a1()
636  { return _v1; }
637 
638  const A1& a1() const
639  { return _v1; }
640 
641  A2& a2()
642  { return _v2; }
643 
644  const A2& a2() const
645  { return _v2; }
646 
647  A3& a3()
648  { return _v3; }
649 
650  const A3& a3() const
651  { return _v3; }
652 
653  A4& a4()
654  { return _v4; }
655 
656  const A4& a4() const
657  { return _v4; }
658 
659  A5& a5()
660  { return _v5; }
661 
662  const A5& a5() const
663  { return _v5; }
664 
665  protected:
666  Composer** onBeginArgs()
667  {
668  _a1.begin(_v1);
669  _a2.begin(_v2);
670  _a3.begin(_v3);
671  _a4.begin(_v4);
672  _a5.begin(_v5);
673 
674  return _args;
675  }
676 
677  virtual void onBeginCall(System::EventLoop& loop)
678  {
679  onInvoke(loop, _v1, _v2, _v3, _v4, _v5);
680  }
681 
682  Decomposer* onEndCall()
683  {
684  const R& r = onResult();
685  _r.begin(r, "");
686  return &_r;
687  }
688 
689  protected:
690  virtual void onInvoke(System::EventLoop& loop,
691  const A1& a1, const A2& a2,
692  const A3& a3, const A4& a4,
693  const A5& a5) = 0;
694 
695  virtual const R& onResult() = 0;
696 
697  private:
698  A1 _v1;
699  A2 _v2;
700  A3 _v3;
701  A4 _v4;
702  A5 _v5;
703 
704  Composer* _args[6];
705  BasicComposer<A1> _a1;
706  BasicComposer<A2> _a2;
707  BasicComposer<A3> _a3;
708  BasicComposer<A4> _a4;
709  BasicComposer<A5> _a5;
710  BasicDecomposer<R> _r;
711 };
712 
713 
714 template < typename R,
715  typename A1,
716  typename A2,
717  typename A3,
718  typename A4>
719 class ActiveProcedure<R, A1, A2, A3, A4,
720  Pt::Void,
721  Pt::Void,
722  Pt::Void,
723  Pt::Void,
724  Pt::Void,
725  Pt::Void> : public ServiceProcedure
726 {
727  public:
728  typedef R ReturnT;
729  typedef A1 Arg1T;
730  typedef A2 Arg2T;
731  typedef A3 Arg3T;
732  typedef A4 Arg4T;
733  typedef Void Arg5T;
734  typedef Void Arg6T;
735  typedef Void Arg7T;
736  typedef Void Arg8T;
737  typedef Void Arg9T;
738  typedef Void Arg10T;
739 
740  public:
741  ActiveProcedure(Responder& resp)
742  : ServiceProcedure(resp)
743  , _a1(&resp.context())
744  , _a2(&resp.context())
745  , _a3(&resp.context())
746  , _a4(&resp.context())
747  , _r(&resp.context())
748  {
749  _args[0] = &_a1;
750  _args[1] = &_a2;
751  _args[2] = &_a3;
752  _args[3] = &_a4;
753  _args[4] = 0;
754  }
755 
756  A1& a1()
757  { return _v1; }
758 
759  const A1& a1() const
760  { return _v1; }
761 
762  A2& a2()
763  { return _v2; }
764 
765  const A2& a2() const
766  { return _v2; }
767 
768  A3& a3()
769  { return _v3; }
770 
771  const A3& a3() const
772  { return _v3; }
773 
774  A4& a4()
775  { return _v4; }
776 
777  const A4& a4() const
778  { return _v4; }
779 
780  protected:
781  Composer** onBeginArgs()
782  {
783  _a1.begin(_v1);
784  _a2.begin(_v2);
785  _a3.begin(_v3);
786  _a4.begin(_v4);
787 
788  return _args;
789  }
790 
791  virtual void onBeginCall(System::EventLoop& loop)
792  {
793  onInvoke(loop, _v1, _v2, _v3, _v4);
794  }
795 
796  Decomposer* onEndCall()
797  {
798  const R& r = onResult();
799  _r.begin(r, "");
800  return &_r;
801  }
802 
803  protected:
804  virtual void onInvoke(System::EventLoop& loop,
805  const A1& a1, const A2& a2,
806  const A3& a3, const A4& a4) = 0;
807 
808  virtual const R& onResult() = 0;
809 
810  private:
811  A1 _v1;
812  A2 _v2;
813  A3 _v3;
814  A4 _v4;
815 
816  Composer* _args[5];
817  BasicComposer<A1> _a1;
818  BasicComposer<A2> _a2;
819  BasicComposer<A3> _a3;
820  BasicComposer<A4> _a4;
821  BasicDecomposer<R> _r;
822 };
823 
824 
825 template < typename R,
826  typename A1,
827  typename A2,
828  typename A3>
829 class ActiveProcedure<R, A1, A2, A3,
830  Pt::Void,
831  Pt::Void,
832  Pt::Void,
833  Pt::Void,
834  Pt::Void,
835  Pt::Void,
836  Pt::Void> : public ServiceProcedure
837 {
838  public:
839  typedef R ReturnT;
840  typedef A1 Arg1T;
841  typedef A2 Arg2T;
842  typedef A3 Arg3T;
843  typedef Void Arg4T;
844  typedef Void Arg5T;
845  typedef Void Arg6T;
846  typedef Void Arg7T;
847  typedef Void Arg8T;
848  typedef Void Arg9T;
849  typedef Void Arg10T;
850 
851  public:
852  ActiveProcedure(Responder& resp)
853  : ServiceProcedure(resp)
854  , _a1(&resp.context())
855  , _a2(&resp.context())
856  , _a3(&resp.context())
857  , _r(&resp.context())
858  {
859  _args[0] = &_a1;
860  _args[1] = &_a2;
861  _args[2] = &_a3;
862  _args[3] = 0;
863 
864  }
865 
866  A1& a1()
867  { return _v1; }
868 
869  const A1& a1() const
870  { return _v1; }
871 
872  A2& a2()
873  { return _v2; }
874 
875  const A2& a2() const
876  { return _v2; }
877 
878  A3& a3()
879  { return _v3; }
880 
881  const A3& a3() const
882  { return _v3; }
883 
884  protected:
885  Composer** onBeginArgs()
886  {
887  _a1.begin(_v1);
888  _a2.begin(_v2);
889  _a3.begin(_v3);
890 
891  return _args;
892  }
893 
894  virtual void onBeginCall(System::EventLoop& loop)
895  {
896  onInvoke(loop, _v1, _v2, _v3);
897  }
898 
899  Decomposer* onEndCall()
900  {
901  const R& r = onResult();
902  _r.begin(r, "");
903  return &_r;
904  }
905 
906  protected:
907  virtual void onInvoke(System::EventLoop& loop,
908  const A1& a1, const A2& a2,
909  const A3& a3) = 0;
910 
911  virtual const R& onResult() = 0;
912 
913  private:
914  A1 _v1;
915  A2 _v2;
916  A3 _v3;
917 
918  Composer* _args[4];
919  BasicComposer<A1> _a1;
920  BasicComposer<A2> _a2;
921  BasicComposer<A3> _a3;
922  BasicDecomposer<R> _r;
923 };
924 
925 
926 template < typename R,
927  typename A1,
928  typename A2>
929 class ActiveProcedure<R, A1, A2,
930  Pt::Void,
931  Pt::Void,
932  Pt::Void,
933  Pt::Void,
934  Pt::Void,
935  Pt::Void,
936  Pt::Void,
937  Pt::Void> : public ServiceProcedure
938 {
939  public:
940  typedef R ReturnT;
941  typedef A1 Arg1T;
942  typedef A2 Arg2T;
943  typedef Void Arg3T;
944  typedef Void Arg4T;
945  typedef Void Arg5T;
946  typedef Void Arg6T;
947  typedef Void Arg7T;
948  typedef Void Arg8T;
949  typedef Void Arg9T;
950  typedef Void Arg10T;
951 
952  public:
953  ActiveProcedure(Responder& resp)
954  : ServiceProcedure(resp)
955  , _a1(&resp.context())
956  , _a2(&resp.context())
957  , _r(&resp.context())
958  {
959  _args[0] = &_a1;
960  _args[1] = &_a2;
961  _args[2] = 0;
962  }
963 
964  A1& a1()
965  { return _v1; }
966 
967  const A1& a1() const
968  { return _v1; }
969 
970  A2& a2()
971  { return _v2; }
972 
973  const A2& a2() const
974  { return _v2; }
975 
976  protected:
977  Composer** onBeginArgs()
978  {
979  _a1.begin(_v1);
980  _a2.begin(_v2);
981 
982  return _args;
983  }
984 
985  virtual void onBeginCall(System::EventLoop& loop)
986  {
987  onInvoke(loop, _v1, _v2);
988  }
989 
990  Decomposer* onEndCall()
991  {
992  const R& r = onResult();
993  _r.begin(r, "");
994  return &_r;
995  }
996 
997  protected:
998  virtual void onInvoke(System::EventLoop& loop,
999  const A1& a1, const A2& a2) = 0;
1000 
1001  virtual const R& onResult() = 0;
1002 
1003  private:
1004  A1 _v1;
1005  A2 _v2;
1006 
1007  Composer* _args[3];
1008  BasicComposer<A1> _a1;
1009  BasicComposer<A2> _a2;
1010  BasicDecomposer<R> _r;
1011 };
1012 
1013 
1014 template <typename R,
1015  typename A1>
1016 class ActiveProcedure<R, A1,
1017  Pt::Void,
1018  Pt::Void,
1019  Pt::Void,
1020  Pt::Void,
1021  Pt::Void,
1022  Pt::Void,
1023  Pt::Void,
1024  Pt::Void,
1025  Pt::Void> : public ServiceProcedure
1026 {
1027  public:
1028  typedef R ReturnT;
1029  typedef A1 Arg1T;
1030  typedef Pt::Void Arg2T;
1031  typedef Pt::Void Arg3T;
1032  typedef Pt::Void Arg4T;
1033  typedef Pt::Void Arg5T;
1034  typedef Pt::Void Arg6T;
1035  typedef Pt::Void Arg7T;
1036  typedef Pt::Void Arg8T;
1037  typedef Pt::Void Arg9T;
1038  typedef Pt::Void Arg10T;
1039 
1040  public:
1041  ActiveProcedure(Responder& resp)
1042  : ServiceProcedure(resp)
1043  , _a1(&resp.context())
1044  , _r(&resp.context())
1045  {
1046  _args[0] = &_a1;
1047  _args[1] = 0;
1048  }
1049 
1050  A1& a1()
1051  { return _v1; }
1052 
1053  const A1& a1() const
1054  { return _v1; }
1055 
1056  protected:
1057  Composer** onBeginArgs()
1058  {
1059  _a1.begin(_v1);
1060  return _args;
1061  }
1062 
1063  virtual void onBeginCall(System::EventLoop& loop)
1064  {
1065  onInvoke(loop, _v1);
1066  }
1067 
1068  Decomposer* onEndCall()
1069  {
1070  const R& r = onResult();
1071  _r.begin(r, "");
1072  return &_r;
1073  }
1074 
1075  protected:
1076  virtual void onInvoke(System::EventLoop& loop, const A1& a1) = 0;
1077 
1078  virtual const R& onResult() = 0;
1079 
1080  private:
1081  A1 _v1;
1082  Composer* _args[2];
1083  BasicComposer<A1> _a1;
1084  BasicDecomposer<R> _r;
1085 };
1086 
1087 
1088 template <typename R>
1089 class ActiveProcedure<R,
1090  Pt::Void,
1091  Pt::Void,
1092  Pt::Void,
1093  Pt::Void,
1094  Pt::Void,
1095  Pt::Void,
1096  Pt::Void,
1097  Pt::Void,
1098  Pt::Void,
1099  Pt::Void> : public ServiceProcedure
1100 {
1101  public:
1102  typedef R ReturnT;
1103  typedef Pt::Void Arg1T;
1104  typedef Pt::Void Arg2T;
1105  typedef Pt::Void Arg3T;
1106  typedef Pt::Void Arg4T;
1107  typedef Pt::Void Arg5T;
1108  typedef Pt::Void Arg6T;
1109  typedef Pt::Void Arg7T;
1110  typedef Pt::Void Arg8T;
1111  typedef Pt::Void Arg9T;
1112  typedef Pt::Void Arg10T;
1113 
1114  public:
1115  ActiveProcedure(Responder& resp)
1116  : ServiceProcedure(resp)
1117  , _r( &resp.context() )
1118  {
1119  _args[0] = 0;
1120  }
1121 
1122  protected:
1123  Composer** onBeginArgs()
1124  {
1125  return _args;
1126  }
1127 
1128  virtual void onBeginCall(System::EventLoop& loop)
1129  {
1130  onInvoke(loop);
1131  }
1132 
1133  Decomposer* onEndCall()
1134  {
1135  const R& r = onResult();
1136  _r.begin(r, "");
1137  return &_r;
1138  }
1139 
1140  protected:
1141  virtual void onInvoke(System::EventLoop& loop) = 0;
1142 
1143  virtual const R& onResult() = 0;
1144 
1145  private:
1146  Composer* _args[1];
1147  BasicDecomposer<R> _r;
1148 };
1149 
1150 
1151 template <typename CallT>
1152 class ActiveProcedureDef : public ServiceProcedureDef
1153 {
1154  public:
1155  ActiveProcedureDef(const Callable<CallT*, Responder&>& cb)
1156  : _cb(0)
1157  {
1158  _cb = cb.clone();
1159  }
1160 
1161  ~ActiveProcedureDef()
1162  {
1163  delete _cb;
1164  }
1165 
1166  protected:
1167  virtual ServiceProcedure* onCreateProcedure(Responder& resp) const
1168  {
1169  typedef typename CallT::ReturnT R;
1170  typedef typename CallT::Arg1T A1;
1171  typedef typename CallT::Arg2T A2;
1172  typedef typename CallT::Arg3T A3;
1173  typedef typename CallT::Arg4T A4;
1174  typedef typename CallT::Arg5T A5;
1175  typedef typename CallT::Arg6T A6;
1176  typedef typename CallT::Arg7T A7;
1177  typedef typename CallT::Arg8T A8;
1178  typedef typename CallT::Arg9T A9;
1179  typedef typename CallT::Arg10T A10;
1180 
1181  ActiveProcedure<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>* proc = _cb->call(resp);
1182  return proc;
1183  }
1184 
1185  private:
1186  const Callable<CallT*, Responder&>* _cb;
1187 };
1188 
1189 } // namespace Remoting
1190 
1191 } // namespace Pt
1192 
1193 #endif // PT_REMOTING_ACTIVEPROCEDURE_H
Pt::Remoting::ServiceProcedure
XML-RPC service procedure.
Definition: ServiceProcedure.h:44
Pt::Remoting::ActiveProcedure
Asynchronous service procedure.
Definition: ActiveProcedure.h:29
Pt::Remoting::ServiceProcedure::ServiceProcedure
ServiceProcedure(Responder &r)
Constructor.
Definition: ServiceProcedure.h:72
Pt::Composer
Composes types during serialization.
Definition: Composer.h:42
Pt::Callable
An interface for all callable entities.
Definition: Callable.h:13
Pt::Remoting::ActiveProcedure::onResult
virtual const R & onResult()=0
Return result of the asynchronous procedure.
Pt::System::EventLoop
Thread-safe event loop supporting I/O multiplexing and Timers.
Definition: EventLoop.h:72
Pt::BasicDecomposer::begin
void begin(const T &type, const char *name)
Begin decomposing a type.
Definition: Decomposer.h:123
Pt::Void
Void type.
Definition: Void.h:43
Pt::Remoting::ActiveProcedure::ActiveProcedure
ActiveProcedure(Responder &resp)
Constructs with Responder.
Pt::Remoting::Responder
Dispatches requests to a service procedure.
Definition: Responder.h:49
Pt::Decomposer
Manages the decomposition of types during serialization.
Definition: Decomposer.h:43
Pt::BasicComposer::begin
void begin(T &type)
Begin composing a type.
Definition: Composer.h:279
Pt::Remoting::ActiveProcedure::onInvoke
virtual void onInvoke(System::EventLoop &loop, const ARGS...&args)=0
Start an asynchronous procedure.
Pt::Callable::clone
virtual Callable * clone() const =0
Returns a copy of this instance.