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