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 
57 // BasicServiceProcedure with 10 arguments
58 template <typename R,
59  typename A1 = Void,
60  typename A2 = Void,
61  typename A3 = Void,
62  typename A4 = Void,
63  typename A5 = Void,
64  typename A6 = Void,
65  typename A7 = Void,
66  typename A8 = Void,
67  typename A9 = Void,
68  typename A10 = Void>
70 {
71  public:
72  BasicServiceProcedure( const Callable<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& cb )
74  , _cb(0)
75  {
76  _cb = cb.clone();
77 
78  _args[0] = &_a1;
79  _args[1] = &_a2;
80  _args[2] = &_a3;
81  _args[3] = &_a4;
82  _args[4] = &_a5;
83  _args[5] = &_a6;
84  _args[6] = &_a7;
85  _args[7] = &_a8;
86  _args[8] = &_a9;
87  _args[9] = &_a10;
88  _args[10] = 0;
89  }
90 
92  {
93  delete _cb;
94  }
95 
97  {
98  return new BasicServiceProcedure(*_cb);
99  }
100 
102  {
103  _a1.begin(_v1);
104  _a2.begin(_v2);
105  _a3.begin(_v3);
106  _a4.begin(_v4);
107  _a5.begin(_v5);
108  _a6.begin(_v6);
109  _a7.begin(_v7);
110  _a8.begin(_v8);
111  _a9.begin(_v9);
112  _a10.begin(_v10);
113 
114  return _args;
115  }
116 
118  {
119  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5, _v6, _v7, _v8, _v9, _v10);
120  _r.begin(_rv);
121  return &_r;
122  }
123 
124  private:
125  typedef typename TypeTraits<A1>::Value V1;
126  typedef typename TypeTraits<A2>::Value V2;
127  typedef typename TypeTraits<A3>::Value V3;
128  typedef typename TypeTraits<A4>::Value V4;
129  typedef typename TypeTraits<A5>::Value V5;
130  typedef typename TypeTraits<A6>::Value V6;
131  typedef typename TypeTraits<A7>::Value V7;
132  typedef typename TypeTraits<A8>::Value V8;
133  typedef typename TypeTraits<A9>::Value V9;
134  typedef typename TypeTraits<A10>::Value V10;
135  typedef typename TypeTraits<R>::Value RV;
136 
137  Callable<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>* _cb;
138  RV _rv;
139  V1 _v1;
140  V2 _v2;
141  V3 _v3;
142  V4 _v4;
143  V5 _v5;
144  V6 _v6;
145  V7 _v7;
146  V8 _v8;
147  V9 _v9;
148  V10 _v10;
149 
150  IComposer* _args[11];
151  Composer<V1> _a1;
152  Composer<V2> _a2;
153  Composer<V3> _a3;
154  Composer<V4> _a4;
155  Composer<V5> _a5;
156  Composer<V6> _a6;
157  Composer<V7> _a7;
158  Composer<V8> _a8;
159  Composer<V9> _a9;
160  Composer<V10> _a10;
161  Decomposer<RV> _r;
162 };
163 
164 
165 // BasicServiceProcedure with 9 arguments
166 template <typename R,
167  typename A1,
168  typename A2,
169  typename A3,
170  typename A4,
171  typename A5,
172  typename A6,
173  typename A7,
174  typename A8,
175  typename A9>
176 class BasicServiceProcedure<R, A1, A2, A3, A4, A5, A6, A7, A8, A9,
177  Void> : public ServiceProcedure
178 {
179  public:
180  BasicServiceProcedure( const Callable<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>& cb )
181  : ServiceProcedure()
182  , _cb(0)
183  {
184  _cb = cb.clone();
185 
186  _args[0] = &_a1;
187  _args[1] = &_a2;
188  _args[2] = &_a3;
189  _args[3] = &_a4;
190  _args[4] = &_a5;
191  _args[5] = &_a6;
192  _args[6] = &_a7;
193  _args[7] = &_a8;
194  _args[8] = &_a9;
195  _args[9] = 0;
196  }
197 
199  {
200  delete _cb;
201  }
202 
204  {
205  return new BasicServiceProcedure(*_cb);
206  }
207 
209  {
210  _a1.begin(_v1);
211  _a2.begin(_v2);
212  _a3.begin(_v3);
213  _a4.begin(_v4);
214  _a5.begin(_v5);
215  _a6.begin(_v6);
216  _a7.begin(_v7);
217  _a8.begin(_v8);
218  _a9.begin(_v9);
219 
220  return _args;
221  }
222 
224  {
225  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5, _v6, _v7, _v8, _v9);
226  _r.begin(_rv);
227  return &_r;
228  }
229 
230  private:
231  typedef typename TypeTraits<A1>::Value V1;
232  typedef typename TypeTraits<A2>::Value V2;
233  typedef typename TypeTraits<A3>::Value V3;
234  typedef typename TypeTraits<A4>::Value V4;
235  typedef typename TypeTraits<A5>::Value V5;
236  typedef typename TypeTraits<A6>::Value V6;
237  typedef typename TypeTraits<A7>::Value V7;
238  typedef typename TypeTraits<A8>::Value V8;
239  typedef typename TypeTraits<A9>::Value V9;
240  typedef typename TypeTraits<R>::Value RV;
241 
242  Callable<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>* _cb;
243  RV _rv;
244  V1 _v1;
245  V2 _v2;
246  V3 _v3;
247  V4 _v4;
248  V5 _v5;
249  V6 _v6;
250  V7 _v7;
251  V8 _v8;
252  V9 _v9;
253 
254  IComposer* _args[10];
255  Composer<V1> _a1;
256  Composer<V2> _a2;
257  Composer<V3> _a3;
258  Composer<V4> _a4;
259  Composer<V5> _a5;
260  Composer<V6> _a6;
261  Composer<V7> _a7;
262  Composer<V8> _a8;
263  Composer<V9> _a9;
264  Decomposer<RV> _r;
265 };
266 
267 
268 // BasicServiceProcedure with 8 arguments
269 template <typename R,
270  typename A1,
271  typename A2,
272  typename A3,
273  typename A4,
274  typename A5,
275  typename A6,
276  typename A7,
277  typename A8>
278 class BasicServiceProcedure<R, A1, A2, A3, A4, A5, A6, A7, A8,
279  Void,
280  Void> : public ServiceProcedure
281 {
282  public:
283  BasicServiceProcedure( const Callable<R, A1, A2, A3, A4, A5, A6, A7, A8>& cb )
284  : ServiceProcedure()
285  , _cb(0)
286  {
287  _cb = cb.clone();
288 
289  _args[0] = &_a1;
290  _args[1] = &_a2;
291  _args[2] = &_a3;
292  _args[3] = &_a4;
293  _args[4] = &_a5;
294  _args[5] = &_a6;
295  _args[6] = &_a7;
296  _args[7] = &_a8;
297  _args[8] = 0;
298  }
299 
301  {
302  delete _cb;
303  }
304 
306  {
307  return new BasicServiceProcedure(*_cb);
308  }
309 
311  {
312  _a1.begin(_v1);
313  _a2.begin(_v2);
314  _a3.begin(_v3);
315  _a4.begin(_v4);
316  _a5.begin(_v5);
317  _a6.begin(_v6);
318  _a7.begin(_v7);
319  _a8.begin(_v8);
320 
321  return _args;
322  }
323 
325  {
326  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5, _v6, _v7, _v8);
327  _r.begin(_rv);
328  return &_r;
329  }
330 
331  private:
332  typedef typename TypeTraits<A1>::Value V1;
333  typedef typename TypeTraits<A2>::Value V2;
334  typedef typename TypeTraits<A3>::Value V3;
335  typedef typename TypeTraits<A4>::Value V4;
336  typedef typename TypeTraits<A5>::Value V5;
337  typedef typename TypeTraits<A6>::Value V6;
338  typedef typename TypeTraits<A7>::Value V7;
339  typedef typename TypeTraits<A8>::Value V8;
340  typedef typename TypeTraits<R>::Value RV;
341 
342  Callable<R, A1, A2, A3, A4, A5, A6, A7, A8>* _cb;
343  RV _rv;
344  V1 _v1;
345  V2 _v2;
346  V3 _v3;
347  V4 _v4;
348  V5 _v5;
349  V6 _v6;
350  V7 _v7;
351  V8 _v8;
352 
353  IComposer* _args[9];
354  Composer<V1> _a1;
355  Composer<V2> _a2;
356  Composer<V3> _a3;
357  Composer<V4> _a4;
358  Composer<V5> _a5;
359  Composer<V6> _a6;
360  Composer<V7> _a7;
361  Composer<V8> _a8;
362  Decomposer<RV> _r;
363 };
364 
365 
366 // BasicServiceProcedure with 7 arguments
367 template <typename R,
368  typename A1,
369  typename A2,
370  typename A3,
371  typename A4,
372  typename A5,
373  typename A6,
374  typename A7>
375 class BasicServiceProcedure<R, A1, A2, A3, A4, A5, A6, A7,
376  Void,
377  Void,
378  Void> : public ServiceProcedure
379 {
380  public:
381  BasicServiceProcedure( const Callable<R, A1, A2, A3, A4, A5, A6, A7>& cb )
382  : ServiceProcedure()
383  , _cb(0)
384  {
385  _cb = cb.clone();
386 
387  _args[0] = &_a1;
388  _args[1] = &_a2;
389  _args[2] = &_a3;
390  _args[3] = &_a4;
391  _args[4] = &_a5;
392  _args[5] = &_a6;
393  _args[6] = &_a7;
394  _args[7] = 0;
395  }
396 
398  {
399  delete _cb;
400  }
401 
403  {
404  return new BasicServiceProcedure(*_cb);
405  }
406 
408  {
409  _a1.begin(_v1);
410  _a2.begin(_v2);
411  _a3.begin(_v3);
412  _a4.begin(_v4);
413  _a5.begin(_v5);
414  _a6.begin(_v6);
415  _a7.begin(_v7);
416 
417  return _args;
418  }
419 
421  {
422  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5, _v6, _v7);
423  _r.begin(_rv);
424  return &_r;
425  }
426 
427  private:
428  typedef typename TypeTraits<A1>::Value V1;
429  typedef typename TypeTraits<A2>::Value V2;
430  typedef typename TypeTraits<A3>::Value V3;
431  typedef typename TypeTraits<A4>::Value V4;
432  typedef typename TypeTraits<A5>::Value V5;
433  typedef typename TypeTraits<A6>::Value V6;
434  typedef typename TypeTraits<A7>::Value V7;
435  typedef typename TypeTraits<R>::Value RV;
436 
437  Callable<R, A1, A2, A3, A4, A5, A6, A7>* _cb;
438  RV _rv;
439  V1 _v1;
440  V2 _v2;
441  V3 _v3;
442  V4 _v4;
443  V5 _v5;
444  V6 _v6;
445  V7 _v7;
446 
447  IComposer* _args[8];
448  Composer<V1> _a1;
449  Composer<V2> _a2;
450  Composer<V3> _a3;
451  Composer<V4> _a4;
452  Composer<V5> _a5;
453  Composer<V6> _a6;
454  Composer<V7> _a7;
455  Decomposer<RV> _r;
456 };
457 
458 
459 // BasicServiceProcedure with 6 arguments
460 template <typename R,
461  typename A1,
462  typename A2,
463  typename A3,
464  typename A4,
465  typename A5,
466  typename A6>
467 class BasicServiceProcedure<R, A1, A2, A3, A4, A5, A6,
468  Void,
469  Void,
470  Void,
471  Void> : public ServiceProcedure
472 {
473  public:
474  BasicServiceProcedure( const Callable<R, A1, A2, A3, A4, A5, A6>& cb )
475  : ServiceProcedure()
476  , _cb(0)
477  {
478  _cb = cb.clone();
479 
480  _args[0] = &_a1;
481  _args[1] = &_a2;
482  _args[2] = &_a3;
483  _args[3] = &_a4;
484  _args[4] = &_a5;
485  _args[5] = &_a6;
486  _args[6] = 0;
487  }
488 
490  {
491  delete _cb;
492  }
493 
495  {
496  return new BasicServiceProcedure(*_cb);
497  }
498 
500  {
501  _a1.begin(_v1);
502  _a2.begin(_v2);
503  _a3.begin(_v3);
504  _a4.begin(_v4);
505  _a5.begin(_v5);
506  _a6.begin(_v6);
507 
508  return _args;
509  }
510 
512  {
513  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5, _v6);
514  _r.begin(_rv);
515  return &_r;
516  }
517 
518  private:
519  typedef typename TypeTraits<A1>::Value V1;
520  typedef typename TypeTraits<A2>::Value V2;
521  typedef typename TypeTraits<A3>::Value V3;
522  typedef typename TypeTraits<A4>::Value V4;
523  typedef typename TypeTraits<A5>::Value V5;
524  typedef typename TypeTraits<A6>::Value V6;
525  typedef typename TypeTraits<R>::Value RV;
526 
527  Callable<R, A1, A2, A3, A4, A5, A6>* _cb;
528  RV _rv;
529  V1 _v1;
530  V2 _v2;
531  V3 _v3;
532  V4 _v4;
533  V5 _v5;
534  V6 _v6;
535 
536  IComposer* _args[7];
537  Composer<V1> _a1;
538  Composer<V2> _a2;
539  Composer<V3> _a3;
540  Composer<V4> _a4;
541  Composer<V5> _a5;
542  Composer<V6> _a6;
543  Decomposer<RV> _r;
544 };
545 
546 
547 // BasicServiceProcedure with 5 arguments
548 template <typename R,
549  typename A1,
550  typename A2,
551  typename A3,
552  typename A4,
553  typename A5>
554 class BasicServiceProcedure<R, A1, A2, A3, A4, A5,
555  Void,
556  Void,
557  Void,
558  Void,
559  Void> : public ServiceProcedure
560 {
561  public:
562  BasicServiceProcedure( const Callable<R, A1, A2, A3, A4, A5>& cb )
563  : ServiceProcedure()
564  , _cb(0)
565  {
566  _cb = cb.clone();
567 
568  _args[0] = &_a1;
569  _args[1] = &_a2;
570  _args[2] = &_a3;
571  _args[3] = &_a4;
572  _args[4] = &_a5;
573  _args[5] = 0;
574  }
575 
577  {
578  delete _cb;
579  }
580 
582  {
583  return new BasicServiceProcedure(*_cb);
584  }
585 
587  {
588  _a1.begin(_v1);
589  _a2.begin(_v2);
590  _a3.begin(_v3);
591  _a4.begin(_v4);
592  _a5.begin(_v5);
593 
594  return _args;
595  }
596 
598  {
599  _rv = _cb->call(_v1, _v2, _v3, _v4, _v5);
600  _r.begin(_rv);
601  return &_r;
602  }
603 
604  private:
605  typedef typename TypeTraits<A1>::Value V1;
606  typedef typename TypeTraits<A2>::Value V2;
607  typedef typename TypeTraits<A3>::Value V3;
608  typedef typename TypeTraits<A4>::Value V4;
609  typedef typename TypeTraits<A5>::Value V5;
610  typedef typename TypeTraits<R>::Value RV;
611 
612  Callable<R, A1, A2, A3, A4, A5>* _cb;
613  RV _rv;
614  V1 _v1;
615  V2 _v2;
616  V3 _v3;
617  V4 _v4;
618  V5 _v5;
619 
620  IComposer* _args[6];
621  Composer<V1> _a1;
622  Composer<V2> _a2;
623  Composer<V3> _a3;
624  Composer<V4> _a4;
625  Composer<V5> _a5;
626  Decomposer<RV> _r;
627 };
628 
629 
630 // BasicServiceProcedure with 4 arguments
631 template <typename R,
632  typename A1,
633  typename A2,
634  typename A3,
635  typename A4>
636 class BasicServiceProcedure<R, A1, A2, A3, A4,
637  Void,
638  Void,
639  Void,
640  Void,
641  Void,
642  Void> : public ServiceProcedure
643 {
644  public:
645  BasicServiceProcedure( const Callable<R, A1, A2, A3, A4>& cb )
646  : ServiceProcedure()
647  , _cb(0)
648  {
649  _cb = cb.clone();
650 
651  _args[0] = &_a1;
652  _args[1] = &_a2;
653  _args[2] = &_a3;
654  _args[3] = &_a4;
655  _args[4] = 0;
656  }
657 
659  {
660  delete _cb;
661  }
662 
664  {
665  return new BasicServiceProcedure(*_cb);
666  }
667 
669  {
670  _a1.begin(_v1);
671  _a2.begin(_v2);
672  _a3.begin(_v3);
673  _a4.begin(_v4);
674 
675  return _args;
676  }
677 
679  {
680  _rv = _cb->call(_v1, _v2, _v3, _v4);
681  _r.begin(_rv);
682  return &_r;
683  }
684 
685  private:
686  typedef typename TypeTraits<A1>::Value V1;
687  typedef typename TypeTraits<A2>::Value V2;
688  typedef typename TypeTraits<A3>::Value V3;
689  typedef typename TypeTraits<A4>::Value V4;
690  typedef typename TypeTraits<R>::Value RV;
691 
692  Callable<R, A1, A2, A3, A4>* _cb;
693  RV _rv;
694  V1 _v1;
695  V2 _v2;
696  V3 _v3;
697  V4 _v4;
698 
699  IComposer* _args[5];
700  Composer<V1> _a1;
701  Composer<V2> _a2;
702  Composer<V3> _a3;
703  Composer<V4> _a4;
704  Decomposer<RV> _r;
705 };
706 
707 
708 // BasicServiceProcedure with 3 arguments
709 template <typename R,
710  typename A1,
711  typename A2,
712  typename A3>
713 class BasicServiceProcedure<R, A1, A2, A3,
714  Void,
715  Void,
716  Void,
717  Void,
718  Void,
719  Void,
720  Void> : public ServiceProcedure
721 {
722  public:
723  BasicServiceProcedure( const Callable<R, A1, A2, A3>& cb )
724  : ServiceProcedure()
725  , _cb(0)
726  {
727  _cb = cb.clone();
728 
729  _args[0] = &_a1;
730  _args[1] = &_a2;
731  _args[2] = &_a3;
732  _args[3] = 0;
733  }
734 
736  {
737  delete _cb;
738  }
739 
741  {
742  return new BasicServiceProcedure(*_cb);
743  }
744 
746  {
747  _a1.begin(_v1);
748  _a2.begin(_v2);
749  _a3.begin(_v3);
750 
751  return _args;
752  }
753 
755  {
756  _rv = _cb->call(_v1, _v2, _v3);
757  _r.begin(_rv);
758  return &_r;
759  }
760 
761  private:
762  typedef typename TypeTraits<A1>::Value V1;
763  typedef typename TypeTraits<A2>::Value V2;
764  typedef typename TypeTraits<A3>::Value V3;
765  typedef typename TypeTraits<R>::Value RV;
766 
767  Callable<R, A1, A2, A3>* _cb;
768  RV _rv;
769  V1 _v1;
770  V2 _v2;
771  V3 _v3;
772 
773  IComposer* _args[4];
774  Composer<V1> _a1;
775  Composer<V2> _a2;
776  Composer<V3> _a3;
777  Decomposer<RV> _r;
778 };
779 
780 
781 // BasicServiceProcedure with 2 arguments
782 template <typename R,
783  typename A1,
784  typename A2>
785 class BasicServiceProcedure<R, A1, A2,
786  Void,
787  Void,
788  Void,
789  Void,
790  Void,
791  Void,
792  Void,
793  Void> : public ServiceProcedure
794 {
795  public:
796  BasicServiceProcedure( const Callable<R, A1, A2>& cb )
797  : ServiceProcedure()
798  , _cb(0)
799  {
800  _cb = cb.clone();
801 
802  _args[0] = &_a1;
803  _args[1] = &_a2;
804  _args[2] = 0;
805  }
806 
808  {
809  delete _cb;
810  }
811 
813  {
814  return new BasicServiceProcedure(*_cb);
815  }
816 
818  {
819  _a1.begin(_v1);
820  _a2.begin(_v2);
821 
822  return _args;
823  }
824 
826  {
827  _rv = _cb->call(_v1, _v2);
828  _r.begin(_rv);
829  return &_r;
830  }
831 
832  private:
833  typedef typename TypeTraits<A1>::Value V1;
834  typedef typename TypeTraits<A2>::Value V2;
835  typedef typename TypeTraits<R>::Value RV;
836 
837  Callable<R, A1, A2>* _cb;
838  RV _rv;
839  V1 _v1;
840  V2 _v2;
841 
842  IComposer* _args[3];
843  Composer<V1> _a1;
844  Composer<V2> _a2;
845  Decomposer<RV> _r;
846 };
847 
848 
849 // BasicServiceProcedure with 1 arguments
850 template <typename R,
851  typename A1>
853  Void,
854  Void,
855  Void,
856  Void,
857  Void,
858  Void,
859  Void,
860  Void,
861  Void> : public ServiceProcedure
862 {
863  public:
864  BasicServiceProcedure( const Callable<R, A1>& cb )
865  : ServiceProcedure()
866  , _cb(0)
867  {
868  _cb = cb.clone();
869 
870  _args[0] = &_a1;
871  _args[1] = 0;
872  }
873 
875  {
876  delete _cb;
877  }
878 
880  {
881  return new BasicServiceProcedure(*_cb);
882  }
883 
885  {
886  _a1.begin(_v1);
887 
888  return _args;
889  }
890 
892  {
893  _rv = _cb->call(_v1);
894  _r.begin(_rv);
895  return &_r;
896  }
897 
898  private:
899  typedef typename TypeTraits<A1>::Value V1;
900  typedef typename TypeTraits<R>::Value RV;
901 
902  Callable<R, A1>* _cb;
903  RV _rv;
904  V1 _v1;
905 
906  IComposer* _args[2];
907  Composer<V1> _a1;
908  Decomposer<RV> _r;
909 };
910 
911 
912 // BasicServiceProcedure with 0 arguments
913 template <typename R>
915  Void,
916  Void,
917  Void,
918  Void,
919  Void,
920  Void,
921  Void,
922  Void,
923  Void,
924  Void> : public ServiceProcedure
925 {
926  public:
927  BasicServiceProcedure( const Callable<R>& cb )
928  : ServiceProcedure()
929  , _cb(0)
930  {
931  _cb = cb.clone();
932 
933  _args[0] = 0;
934  }
935 
937  {
938  delete _cb;
939  }
940 
942  {
943  return new BasicServiceProcedure(*_cb);
944  }
945 
947  {
948 
949  return _args;
950  }
951 
953  {
954  _rv = _cb->call();
955  _r.begin(_rv);
956  return &_r;
957  }
958 
959  private:
960  typedef typename TypeTraits<R>::Value RV;
961 
962  Callable<R>* _cb;
963  RV _rv;
964 
965  IComposer* _args[1];
966  Decomposer<RV> _r;
967 };
968 
969 }
970 
971 #endif // CXXTOOLS_SERVICEPROCEDURE_H