libalcommon  1.14
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
alproxy.hxx
1 
7 #pragma once
8 #ifndef _LIBALCOMMON_ALCOMMON_ALPROXY_HXX_
9 #define _LIBALCOMMON_ALCOMMON_ALPROXY_HXX_
10 
11 #include <alcommon/detail/alpcall.h>
12 
13 namespace AL
14 {
15 
16 #define CHECK_RESULT() \
17  if (getParamStrType<R>() != lDesc->returnInfo.strType) \
18  { \
19  throw ALERROR("ALProxy", "call", \
20  std::string("wrong return type for function '") + \
21  pName + "'" + \
22  " type is '" + getParamStrType<R>() + "'" + \
23  " instead of '" + lDesc->returnInfo.strType); \
24  }
25 
26 #define CHECK_PARAM(x) \
27  if (getParamStrType<P ## x>() != lDesc->parameters[x-1].strType) \
28  { \
29  throw ALERROR("ALProxy", "call/pCall", \
30  std::string("When trying to call module '") + \
31  xGetModuleName() + "'" \
32  " function '" + pName + "' parameter #" + \
33  (char) (x + '0') + \
34  " is of type " + getParamStrType<P ## x>() + \
35  " instead of type " + \
36  lDesc->parameters[x-1].strType); \
37  }
38 
39  template <typename R>
40  R ALProxy::call(const std::string& pName)
41  {
42  if (isLocal())
43  {
44  if (isScript())
45  {
46  AL::ALValue param;
47  AL::ALValue result;
48  xExecute(pName, param, result);
49  AL::detail::converter<R> conv;
50  return conv.convertFromALValue(result);
51  }
52  ALMethodInfo *lDesc = xLookupMethod(pName);
53  if (!lDesc)
54  {
55  std::vector<std::string> param;
56  lDesc = xLookupMethod(pName, param, true);
57  }
58  CHECK_RESULT();
59  return (*(detail::ALFunctor_0<ALModule, R> *)(lDesc->getFunction()))();
60  }
61  AL::ALValue p, r;
62  CALL_METHODS(pName, p, r);
63  if (!r.isValid())
64  throw ALERROR("ALProxy", "call", "Waiting for the result of a void function");
65  AL::detail::converter<R> conv;
66  return conv.convertFromALValue(r);
67  }
68 
69  template <typename R, typename P1>
70  R ALProxy::call(const std::string& pName, const P1 &p1)
71  {
72  if (isLocal())
73  {
74  if (isScript())
75  {
76  AL::ALValue param;
77  AL::ALValue result;
78  param.arraySetSize(1);
79  param[0] = p1;
80  xExecute(pName, param, result);
81  AL::detail::converter<R> conv;
82  R resultConv = conv.convertFromALValue(result);
83  return resultConv;
84  }
85  ALMethodInfo *lDesc = xLookupMethod(pName);
86  if (!lDesc)
87  {
88  std::vector<std::string> param;
89  param.push_back(getParamStrType<P1>());
90  lDesc = xLookupMethod(pName, param,false);
91  }
92  CHECK_RESULT();
93  CHECK_PARAM(1);
94  return (*(detail::ALFunctor_1<ALModule, P1, R> *)(lDesc->getFunction()))(p1);
95  }
96  AL::ALValue p, r;
97  p.arraySetSize(1);
98  p[0] = p1;
99  CALL_METHODS(pName, p, r);
100  if ( !r.isValid() )
101  {
102  std::string error = std::string("Waiting for the result of a void function ") + pName + std::string(" ") + p.toString(VerbosityMini) + std::string(" ") + r.toString(VerbosityMini);
103  throw ALERROR("ALProxy", "call", error);
104  }
105  AL::detail::converter<R> conv;
106  R resultConv = conv.convertFromALValue(r);
107  return resultConv;
108  }
109 
110 
111  template <typename R, typename P1, typename P2>
112  R ALProxy::call(const std::string& pName, const P1 &p1, const P2 &p2)
113  {
114  if (isLocal())
115  {
116  if (isScript())
117  {
118  AL::ALValue param;
119  AL::ALValue result;
120  param.arraySetSize(2);
121  param[0] = p1;
122  param[1] = p2;
123  xExecute(pName, param, result);
124  return result;
125  }
126  ALMethodInfo *lDesc = xLookupMethod(pName);
127  if (!lDesc)
128  {
129  std::vector<std::string> param;
130  param.push_back(getParamStrType<P1>());
131  param.push_back(getParamStrType<P2>());
132  lDesc = xLookupMethod(pName, param,false);
133  }
134  CHECK_RESULT();
135  CHECK_PARAM(1);
136  CHECK_PARAM(2);
137  return (*(detail::ALFunctor_2<ALModule, P1, P2, R> *)(lDesc->getFunction()))(p1, p2);
138  }
139  AL::ALValue p, r;
140  p.arraySetSize(2);
141  p[0] = p1;
142  p[1] = p2;
143  CALL_METHODS(pName, p, r);
144  if ( !r.isValid() )
145  throw ALERROR("ALProxy", "call", "Waiting for the result of a void function");
146  AL::detail::converter<R> conv;
147  R resultConv = conv.convertFromALValue(r);
148  return resultConv;
149  }
150 
151 
152  template <typename R, typename P1, typename P2, typename P3>
153  R ALProxy::call(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3)
154  {
155  if (isLocal())
156  {
157  if (isScript())
158  {
159  AL::ALValue param;
160  AL::ALValue result;
161  param.arraySetSize(3);
162  param[0] = p1;
163  param[1] = p2;
164  param[2] = p3;
165  xExecute(pName, param, result);
166  return result;
167  }
168  ALMethodInfo *lDesc = xLookupMethod(pName);
169  if (!lDesc)
170  {
171  std::vector<std::string> param;
172  param.push_back(getParamStrType<P1>());
173  param.push_back(getParamStrType<P2>());
174  param.push_back(getParamStrType<P3>());
175  lDesc = xLookupMethod(pName, param, false);
176  }
177  CHECK_RESULT();
178  CHECK_PARAM(1);
179  CHECK_PARAM(2);
180  CHECK_PARAM(3);
181  return (*(detail::ALFunctor_3<ALModule, P1, P2, P3, R> *)(lDesc->getFunction()))(p1, p2, p3);
182  }
183  AL::ALValue p, r;
184  p.arraySetSize(3);
185  p[0] = p1;
186  p[1] = p2;
187  p[2] = p3;
188 
189  CALL_METHODS(pName, p, r);
190  if ( !r.isValid() )
191  throw ALERROR("ALProxy", "call", "Waiting for the result of a void function");
192  AL::detail::converter<R> conv;
193  R resultConv = conv.convertFromALValue(r);
194  return resultConv;
195  }
196 
197 
198  template <typename R, typename P1, typename P2, typename P3, typename P4>
199  R ALProxy::call(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4)
200  {
201  if (isLocal())
202  {
203  if (isScript())
204  {
205  AL::ALValue param;
206  AL::ALValue result;
207  param.arraySetSize(4);
208  param[0] = p1;
209  param[1] = p2;
210  param[2] = p3;
211  param[3] = p4;
212  xExecute(pName, param, result);
213  return result;
214  }
215  ALMethodInfo *lDesc = xLookupMethod(pName);
216  if (!lDesc)
217  {
218  std::vector<std::string> param;
219  param.push_back(getParamStrType<P1>());
220  param.push_back(getParamStrType<P2>());
221  param.push_back(getParamStrType<P3>());
222  param.push_back(getParamStrType<P4>());
223  lDesc = xLookupMethod(pName, param, false);
224  }
225  CHECK_RESULT();
226  CHECK_PARAM(1);
227  CHECK_PARAM(2);
228  CHECK_PARAM(3);
229  CHECK_PARAM(4);
230  return (*(detail::ALFunctor_4<ALModule, P1, P2, P3, P4, R> *)(lDesc->getFunction()))(p1, p2, p3, p4);
231  }
232  AL::ALValue p, r;
233  p.arraySetSize(4);
234  p[0] = p1;
235  p[1] = p2;
236  p[2] = p3;
237  p[3] = p4;
238  CALL_METHODS(pName, p, r);
239  if ( !r.isValid() )
240  throw ALERROR("ALProxy", "call", "Waiting for the result of a void function");
241  AL::detail::converter<R> conv;
242  R resultConv = conv.convertFromALValue(r);
243  return resultConv;
244  }
245 
246 
247  template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
248  R ALProxy::call(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5)
249  {
250  if (isLocal())
251  {
252  if (isScript())
253  {
254  AL::ALValue param;
255  AL::ALValue result;
256  param.arraySetSize(5);
257  param[0] = p1;
258  param[1] = p2;
259  param[2] = p3;
260  param[3] = p4;
261  param[4] = p5;
262  xExecute(pName, param, result);
263  return result;
264  }
265  ALMethodInfo *lDesc = xLookupMethod(pName);
266  if (!lDesc)
267  {
268  std::vector<std::string> param;
269  param.push_back(getParamStrType<P1>());
270  param.push_back(getParamStrType<P2>());
271  param.push_back(getParamStrType<P3>());
272  param.push_back(getParamStrType<P4>());
273  param.push_back(getParamStrType<P5>());
274  lDesc = xLookupMethod(pName, param, false);
275  }
276  CHECK_RESULT();
277  CHECK_PARAM(1);
278  CHECK_PARAM(2);
279  CHECK_PARAM(3);
280  CHECK_PARAM(4);
281  CHECK_PARAM(5);
282  return (*(detail::ALFunctor_5<ALModule, P1, P2, P3, P4, P5, R> *)(lDesc->getFunction()))(p1, p2, p3, p4, p5);
283  }
284  AL::ALValue p, r;
285  p.arraySetSize(5);
286  p[0] = p1;
287  p[1] = p2;
288  p[2] = p3;
289  p[3] = p4;
290  p[4] = p5;
291  CALL_METHODS(pName, p, r);
292  if ( !r.isValid() )
293  throw ALERROR("ALProxy", "call", "Waiting for the result of a void function");
294  AL::detail::converter<R> conv;
295  R resultConv = conv.convertFromALValue(r);
296  return resultConv;
297  }
298 
299 
300  template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
301  R ALProxy::call(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5, const P6 &p6)
302  {
303  if (isLocal())
304  {
305  if (isScript())
306  {
307  AL::ALValue param;
308  AL::ALValue result;
309  param.arraySetSize(6);
310  param[0] = p1;
311  param[1] = p2;
312  param[2] = p3;
313  param[3] = p4;
314  param[4] = p5;
315  param[5] = p6;
316  xExecute(pName, param, result);
317  return result;
318  }
319 
320  ALMethodInfo *lDesc = xLookupMethod(pName);
321  if (!lDesc)
322  throw ALERROR("ALProxy", "call", "Function does not exist");
323  CHECK_RESULT();
324  CHECK_PARAM(1);
325  CHECK_PARAM(2);
326  CHECK_PARAM(3);
327  CHECK_PARAM(4);
328  CHECK_PARAM(5);
329  CHECK_PARAM(6);
330  return (*(detail::ALFunctor_6<ALModule, P1, P2, P3, P4, P5, P6, R> *)(lDesc->getFunction()))(p1, p2, p3, p4, p5, p6);
331  }
332  AL::ALValue p, r;
333  p.arraySetSize(6);
334  p[0] = p1;
335  p[1] = p2;
336  p[2] = p3;
337  p[3] = p4;
338  p[4] = p5;
339  p[5] = p6;
340  CALL_METHODS(pName, p, r);
341  if ( !r.isValid() )
342  throw ALERROR("ALProxy", "call", "Waiting for the result of a void function");
343  AL::detail::converter<R> conv;
344  R resultConv = conv.convertFromALValue(r);
345  return resultConv;
346  }
347 
348  inline
349  void ALProxy::callVoid(const std::string& pName)
350  {
351  if (isLocal())
352  {
353  if (isScript())
354  {
355  AL::ALValue param;
356  AL::ALValue result;
357  xExecute(pName, param, result);
358  return;
359  }
360  ALMethodInfo *lDesc = xLookupMethod(pName);
361  if (!lDesc)
362  throw ALERROR("ALProxy", "getMethodInfo", std::string("Function ") + pName + " does not exist in module " + xGetModuleName() );
363  (*(detail::ALFunctor_0<ALModule, ALVoid> *)(xLookupMethod(pName)->ptrOnMethod.get()))();
364  return;
365  }
366  AL::ALValue p, r;
367  CALL_METHODS(pName, p, r);
368  return;
369  }
370 
371  template <typename P1>
372  void ALProxy::callVoid(const std::string& pName, const P1 &p1)
373  {
374  if (isLocal())
375  {
376  if (isScript())
377  {
378  AL::ALValue param;
379  AL::ALValue result;
380  param.arraySetSize(1);
381  AL::detail::converter<P1> conv;
382  param[0] = conv.convertToALValue(p1);
383  xExecute(pName, param, result);
384  return;
385  }
386  ALMethodInfo *lDesc = xLookupMethod(pName);
387  if (!lDesc)
388  {
389  std::vector<std::string> param;
390  param.push_back(getParamStrType<P1>());
391  lDesc = xLookupMethod(pName, param, false);
392  }
393  CHECK_PARAM(1);
394  (*(detail::ALFunctor_1<ALModule, P1, void> *)(lDesc->getFunction()))(p1);
395  return;
396  }
397  AL::ALValue p, r;
398  p.arraySetSize(1);
399  AL::detail::converter<P1> conv;
400  p[0] = conv.convertToALValue(p1);
401  CALL_METHODS(pName, p, r);
402  return;
403  }
404 
405  template <typename P1, typename P2>
406  void ALProxy::callVoid(const std::string& pName, const P1 &p1, const P2 &p2)
407  {
408  if (isLocal())
409  {
410  if (isScript())
411  {
412  AL::ALValue param;
413  AL::ALValue result;
414  param.arraySetSize(2);
415  param[0] = p1;
416  param[1] = p2;
417  xExecute(pName, param, result);
418  return;
419  }
420  ALMethodInfo *lDesc = xLookupMethod(pName);
421  if (!lDesc)
422  {
423  std::vector<std::string> param;
424  param.push_back(getParamStrType<P1>());
425  param.push_back(getParamStrType<P2>());
426  lDesc = xLookupMethod(pName, param, false);
427  }
428  CHECK_PARAM(1);
429  CHECK_PARAM(2);
430  (*(detail::ALFunctor_2<ALModule, P1, P2, void> *)(lDesc->getFunction()))(p1, p2);
431  return;
432  }
433  AL::ALValue p, r;
434  p.arraySetSize(2);
435  p[0] = p1;
436  p[1] = p2;
437  CALL_METHODS(pName, p, r);
438  }
439 
440  template <typename P1, typename P2, typename P3>
441  void ALProxy::callVoid(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3)
442  {
443  if (isLocal())
444  {
445  if (isScript())
446  {
447  AL::ALValue param;
448  AL::ALValue result;
449  param.arraySetSize(3);
450  param[0] = p1;
451  param[1] = p2;
452  param[2] = p3;
453  xExecute(pName, param, result);
454  return;
455  }
456  ALMethodInfo *lDesc = xLookupMethod(pName);
457  if (!lDesc)
458  {
459  std::vector<std::string> param;
460  param.push_back(getParamStrType<P1>());
461  param.push_back(getParamStrType<P2>());
462  param.push_back(getParamStrType<P3>());
463  lDesc = xLookupMethod(pName, param, false);
464  }
465  CHECK_PARAM(1);
466  CHECK_PARAM(2);
467  CHECK_PARAM(3);
468  (*(detail::ALFunctor_3<ALModule, P1, P2, P3, void> *)(lDesc->getFunction()))(p1, p2, p3);
469  return;
470  }
471  AL::ALValue p, r;
472  p.arraySetSize(3);
473  p[0] = p1;
474  p[1] = p2;
475  p[2] = p3;
476  CALL_METHODS(pName, p, r);
477  }
478 
479  template <typename P1, typename P2, typename P3, typename P4>
480  void ALProxy::callVoid(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4)
481  {
482  if (isLocal())
483  {
484  if (isScript())
485  {
486  AL::ALValue param;
487  AL::ALValue result;
488  param.arraySetSize(4);
489  param[0] = p1;
490  param[1] = p2;
491  param[2] = p3;
492  param[3] = p4;
493  xExecute(pName, param, result);
494  return;
495  }
496  ALMethodInfo *lDesc = xLookupMethod(pName);
497  if (!lDesc)
498  {
499  std::vector<std::string> param;
500  param.push_back(getParamStrType<P1>());
501  param.push_back(getParamStrType<P2>());
502  param.push_back(getParamStrType<P3>());
503  param.push_back(getParamStrType<P4>());
504  lDesc = xLookupMethod(pName, param, false);
505  }
506  CHECK_PARAM(1);
507  CHECK_PARAM(2);
508  CHECK_PARAM(3);
509  CHECK_PARAM(4);
510  (*(detail::ALFunctor_4<ALModule, P1, P2, P3, P4, ALVoid> *)(lDesc->getFunction()))(p1, p2, p3, p4);
511  return;
512  }
513  AL::ALValue p, r;
514  p.arraySetSize(4);
515  p[0] = p1;
516  p[1] = p2;
517  p[2] = p3;
518  p[3] = p4;
519  CALL_METHODS(pName, p, r);
520  }
521 
522  template <typename P1, typename P2, typename P3, typename P4, typename P5>
523  void ALProxy::callVoid(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5)
524  {
525  if (isLocal())
526  {
527  if (isScript())
528  {
529  AL::ALValue param;
530  AL::ALValue result;
531  param.arraySetSize(5);
532  param[0] = p1;
533  param[1] = p2;
534  param[2] = p3;
535  param[3] = p4;
536  param[4] = p5;
537  xExecute(pName, param, result);
538  return;
539  }
540  ALMethodInfo *lDesc = xLookupMethod(pName);
541  if (!lDesc)
542  {
543  std::vector<std::string> param;
544  param.push_back(getParamStrType<P1>());
545  param.push_back(getParamStrType<P2>());
546  param.push_back(getParamStrType<P3>());
547  param.push_back(getParamStrType<P4>());
548  param.push_back(getParamStrType<P5>());
549  lDesc = xLookupMethod(pName, param, false);
550  }
551  CHECK_PARAM(1);
552  CHECK_PARAM(2);
553  CHECK_PARAM(3);
554  CHECK_PARAM(4);
555  CHECK_PARAM(5);
556  (*(detail::ALFunctor_5<ALModule, P1, P2, P3, P4, P5, ALVoid> *)(lDesc->getFunction()))(p1, p2, p3, p4, p5);
557  return;
558  }
559  AL::ALValue p, r;
560  p.arraySetSize(5);
561  p[0] = p1;
562  p[1] = p2;
563  p[2] = p3;
564  p[3] = p4;
565  p[4] = p5;
566  CALL_METHODS(pName, p, r);
567  }
568 
569 
570  template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
571  void ALProxy::callVoid(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5, const P6 &p6)
572  {
573  if (isLocal())
574  {
575  if (isScript())
576  {
577  AL::ALValue param;
578  AL::ALValue result;
579  param.arraySetSize(6);
580  param[0] = p1;
581  param[1] = p2;
582  param[2] = p3;
583  param[3] = p4;
584  param[4] = p5;
585  param[5] = p6;
586 
587  xExecute(pName, param, result);
588  return;
589  }
590  ALMethodInfo *lDesc = xLookupMethod(pName);
591  if (!lDesc)
592  throw ALERROR("ALProxy", "call", "Function does not exist");
593  CHECK_PARAM(1);
594  CHECK_PARAM(2);
595  CHECK_PARAM(3);
596  CHECK_PARAM(4);
597  CHECK_PARAM(5);
598  CHECK_PARAM(6);
599  (*(detail::ALFunctor_6<ALModule, P1, P2, P3, P4, P5, P6, ALVoid> *)(lDesc->getFunction()))(p1, p2, p3, p4, p5, p6);
600  return;
601  }
602  AL::ALValue p, r;
603  p.arraySetSize(6);
604  p[0] = p1;
605  p[1] = p2;
606  p[2] = p3;
607  p[3] = p4;
608  p[4] = p5;
609  p[5] = p6;
610  CALL_METHODS(pName, p, r);
611  }
612 
613  inline
614  int ALProxy::pCall(const std::string& pName)
615  {
616  if (isLocal())
617  {
618  if (isScript())
619  {
620  AL::ALValue param;
621  return xPCallScript(pName, param);
622  }
623  ALMethodInfo *lDesc = xLookupMethod(pName);
624  if (!lDesc)
625  throw ALERROR("ALProxy", "getMethodInfo", std::string("Function ") + pName + " does not exist in module " + xGetModuleName() );
626  boost::shared_ptr<detail::ALTaskInfo> r = xCreateTaskInfo(pName);
627  detail::PCallBase *pcall(new detail::_pcall0((detail::ALFunctor_0<ALModule, ALVoid> *)(lDesc->getFunction()),r,getModuleCore()));
628  xAddTask(r->toString(), pcall);
629  return r->getID();
630  }
631  AL::ALValue p,r;
632  PCALL_METHODS(pName, p, r);
633  return r;
634  }
635 
636 
637  template <typename P1>
638  int ALProxy::pCall(const std::string& pName, const P1 &p1)
639  {
640  if (isLocal())
641  {
642  if (isScript())
643  {
644  AL::ALValue param;
645  param.arraySetSize(1);
646  AL::detail::converter<P1> conv;
647  param[0] = conv.convertToALValue(p1);
648  return xPCallScript(pName, param);
649  }
650  ALMethodInfo *lDesc = xLookupMethod(pName);
651  if (!lDesc)
652  {
653  std::vector<std::string> param;
654  param.push_back(getParamStrType<P1>());
655  lDesc = xLookupMethod(pName, param, true);
656  }
657  CHECK_PARAM(1);
658  boost::shared_ptr<detail::ALTaskInfo> r = xCreateTaskInfo(pName);
659  detail::PCallBase *task(new detail::_pcall1<P1>((detail::ALFunctor_1<ALModule, P1, ALVoid> *)(lDesc->getFunction()), p1,getModuleCore(),r ));
660  xAddTask(r->toString(), task);
661  return r->getID();
662  }
663  AL::ALValue p, r;
664  p.arraySetSize(1);
665  AL::detail::converter<P1> conv;
666  p[0] = conv.convertToALValue(p1);
667  PCALL_METHODS(pName, p, r);
668  return r;
669  }
670 
671 
672  template <typename P1, typename P2>
673  int ALProxy::pCall(const std::string& pName, const P1 &p1, const P2 &p2)
674  {
675  if (isLocal())
676  {
677  if (isScript())
678  {
679  AL::ALValue param;
680  param.arraySetSize(2);
681  param[0] = p1;
682  param[1] = p2;
683  return xPCallScript(pName, param);
684  }
685  ALMethodInfo *lDesc = xLookupMethod(pName);
686  if (!lDesc)
687  {
688  std::vector<std::string> param;
689  param.push_back(getParamStrType<P1>());
690  param.push_back(getParamStrType<P2>());
691  lDesc = xLookupMethod(pName, param, true);
692  }
693  CHECK_PARAM(1);
694  CHECK_PARAM(2);
695  boost::shared_ptr<detail::ALTaskInfo> r = xCreateTaskInfo(pName);
696  detail::PCallBase *task(new detail::_pcall2<P1, P2>((detail::ALFunctor_2<ALModule, P1, P2, ALVoid> *)(lDesc->getFunction()), p1, p2, getModuleCore(), r));
697  xAddTask(r->toString(), task);
698  return r->getID();
699  }
700  AL::ALValue p, r;
701  p.arraySetSize(2);
702  p[0] = p1;
703  p[1] = p2;
704  PCALL_METHODS(pName, p, r);
705  return r;
706  }
707 
708  template <typename P1, typename P2, typename P3>
709  int ALProxy::pCall(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3)
710  {
711  if (isLocal())
712  {
713  if (isScript())
714  {
715  AL::ALValue param;
716  param.arraySetSize(3);
717  param[0] = p1;
718  param[1] = p2;
719  param[2] = p3;
720  return xPCallScript(pName, param);
721  }
722  ALMethodInfo *lDesc = xLookupMethod(pName);
723  if (!lDesc)
724  {
725  std::vector<std::string> param;
726  param.push_back(getParamStrType<P1>());
727  param.push_back(getParamStrType<P2>());
728  param.push_back(getParamStrType<P3>());
729  lDesc = xLookupMethod(pName, param, true);
730  }
731  CHECK_PARAM(1);
732  CHECK_PARAM(2);
733  CHECK_PARAM(3);
734  boost::shared_ptr<detail::ALTaskInfo> r = xCreateTaskInfo(pName);
735  detail::PCallBase *task(new detail::_pcall3<P1, P2, P3>((detail::ALFunctor_3<ALModule, P1, P2, P3, ALVoid> *)(lDesc->getFunction()), p1, p2, p3,getModuleCore(),r));
736  xAddTask(r->toString(), task);
737  return r->getID();
738  }
739  AL::ALValue p, r;
740  p.arraySetSize(3);
741  p[0] = p1;
742  p[1] = p2;
743  p[2] = p3;
744  PCALL_METHODS(pName, p, r);
745  return r;
746  }
747 
748  template <typename P1, typename P2, typename P3, typename P4>
749  int ALProxy::pCall(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4)
750  {
751  if (isLocal())
752  {
753  if (isScript())
754  {
755  AL::ALValue param;
756  param.arraySetSize(4);
757  param[0] = p1;
758  param[1] = p2;
759  param[2] = p3;
760  param[3] = p4;
761  return xPCallScript(pName, param);
762  }
763  ALMethodInfo *lDesc = xLookupMethod(pName);
764  if (!lDesc)
765  {
766  std::vector<std::string> param;
767  param.push_back(getParamStrType<P1>());
768  param.push_back(getParamStrType<P2>());
769  param.push_back(getParamStrType<P3>());
770  param.push_back(getParamStrType<P4>());
771  lDesc = xLookupMethod(pName, param, true);
772  }
773  CHECK_PARAM(1);
774  CHECK_PARAM(2);
775  CHECK_PARAM(3);
776  CHECK_PARAM(4);
777  boost::shared_ptr<detail::ALTaskInfo> r = xCreateTaskInfo(pName);
778  detail::PCallBase *task(new detail::_pcall4<P1, P2, P3, P4>((detail::ALFunctor_4<ALModule, P1, P2, P3, P4, ALVoid> *)(lDesc->getFunction()), p1, p2, p3, p4,getModuleCore(), r ));
779  xAddTask(r->toString(), task);
780  return r->getID();
781  }
782  AL::ALValue p, r;
783  p.arraySetSize(4);
784  p[0] = p1;
785  p[1] = p2;
786  p[2] = p3;
787  p[3] = p4;
788  PCALL_METHODS(pName, p, r);
789  return r;
790  }
791 
792  template <typename P1, typename P2, typename P3, typename P4, typename P5>
793  int ALProxy::pCall(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5)
794  {
795  if (isLocal())
796  {
797  if (isScript())
798  {
799  AL::ALValue param;
800  param.arraySetSize(5);
801  param[0] = p1;
802  param[1] = p2;
803  param[2] = p3;
804  param[3] = p4;
805  param[4] = p5;
806  return xPCallScript(pName, param);
807  }
808  ALMethodInfo *lDesc = xLookupMethod(pName);
809  if (!lDesc)
810  {
811  std::vector<std::string> param;
812  param.push_back(getParamStrType<P1>());
813  param.push_back(getParamStrType<P2>());
814  param.push_back(getParamStrType<P3>());
815  param.push_back(getParamStrType<P4>());
816  param.push_back(getParamStrType<P5>());
817  lDesc = xLookupMethod(pName, param, false);
818  }
819  CHECK_PARAM(1);
820  CHECK_PARAM(2);
821  CHECK_PARAM(3);
822  CHECK_PARAM(4);
823  CHECK_PARAM(5);
824  boost::shared_ptr<detail::ALTaskInfo> r = xCreateTaskInfo(pName);
825  detail::PCallBase *task(new detail::_pcall5<P1, P2, P3, P4, P5>((detail::ALFunctor_5<ALModule, P1, P2, P3, P4, P5, ALVoid> *)(lDesc->getFunction()), p1, p2, p3, p4, p5, getModuleCore(), r));
826  xAddTask(r->toString(), task);
827  return r->getID();
828  }
829  AL::ALValue p, r;
830  p.arraySetSize(5);
831  p[0] = p1;
832  p[1] = p2;
833  p[2] = p3;
834  p[3] = p4;
835  p[4] = p5;
836  PCALL_METHODS(pName, p, r);
837  return r;
838  }
839 
840 
841  template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
842  int ALProxy::pCall(const std::string& pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5, const P6 &p6)
843  {
844  if (isLocal())
845  {
846  if (isScript())
847  {
848  AL::ALValue param;
849  param.arraySetSize(6);
850  param[0] = p1;
851  param[1] = p2;
852  param[2] = p3;
853  param[3] = p4;
854  param[4] = p5;
855  param[5] = p6;
856  return xPCallScript(pName, param);
857  }
858  ALMethodInfo *lDesc = xLookupMethod(pName);
859  if (!lDesc)
860  throw ALERROR("ALProxy", "call", "Function does not exist");
861  CHECK_PARAM(1);
862  CHECK_PARAM(2);
863  CHECK_PARAM(3);
864  CHECK_PARAM(4);
865  CHECK_PARAM(5);
866  CHECK_PARAM(6);
867  boost::shared_ptr<detail::ALTaskInfo> r = xCreateTaskInfo(pName);
868  detail::PCallBase *task(new detail::_pcall6<P1, P2, P3, P4, P5, P6>((detail::ALFunctor_6<ALModule, P1, P2, P3, P4, P5, P6, ALVoid> *)(lDesc->getFunction()), p1, p2, p3, p4, p5, p6, getModuleCore(), r));
869  xAddTask(r->toString(), task);
870  return r->getID();
871  }
872  AL::ALValue p, r;
873  p.arraySetSize(6);
874  p[0] = p1;
875  p[1] = p2;
876  p[2] = p3;
877  p[3] = p4;
878  p[4] = p5;
879  p[5] = p6;
880  PCALL_METHODS(pName, p, r);
881  return r;
882  }
883 }
884 
885 #endif // _LIBALCOMMON_ALCOMMON_ALPROXY_HXX_
886 
Copyright Aldebaran Robotics