dynamic-graph  4.4.0
Dynamic graph library
command-bind.h
1 //
2 // Copyright 2010 CNRS
3 //
4 // Author: Nicolas Mansard
5 //
6 
7 #ifndef __dg_command_bind_h__
8 #define __dg_command_bind_h__
9 
10 /* Create a command from a bind directly. Examples are:
11 
12  * addCommand("myProcVoid",
13  * makeCommandVoid0(*this,&ClassName::functionNoArg,
14  * docCommandVoid0("Simple line doc here.")));
15 
16  * addCommand("myProcOneString",
17  * makeCommandVoid1(*this,&EntityName::functionOneStringArg,
18  * docCommandVoid1("Simple line doc here.",
19  * "string")));
20  *
21  */
22 
23 #include "dynamic-graph/command.h"
24 #include <boost/assign/list_of.hpp>
25 #include <boost/bind.hpp>
26 #include <boost/function.hpp>
27 
28 /* --- FUNCTION 0 ARGS ----------------------------------------------------- */
29 namespace dynamicgraph {
30 namespace command {
31 
32 template <class E> struct CommandVoid0 : public Command {
33  CommandVoid0(E &entity, boost::function<void(void)> function,
34  const std::string &docString)
35  : Command(entity, EMPTY_ARG, docString), fptr(function) {}
36 
37 protected:
38  virtual Value doExecute() {
39  assert(getParameterValues().size() == 0);
40  fptr();
41  return Value(); // void
42  }
43 
44 private:
45  boost::function<void(void)> fptr;
46 };
47 
48 template <class E>
49 CommandVoid0<E> *makeCommandVoid0(E &entity,
50  boost::function<void(void)> function,
51  const std::string &docString) {
52  return new CommandVoid0<E>(entity, function, docString);
53 }
54 
55 template <class E>
56 CommandVoid0<E> *makeCommandVoid0(E &entity,
57  boost::function<void(E *)> function,
58  const std::string &docString) {
59  return new CommandVoid0<E>(entity, boost::bind(function, &entity), docString);
60 }
61 
62 template <class E>
63 CommandVoid0<E> *makeCommandVoid0(E &entity, void (E::*function)(void),
64  const std::string &docString) {
65  return new CommandVoid0<E>(entity, boost::bind(function, &entity), docString);
66 }
67 
68 inline std::string docCommandVoid0(const std::string &doc) {
69  return std::string("\n") + doc + "\n\nNo input.\nVoid return.\n\n";
70 }
71 
72 } // namespace command
73 } // namespace dynamicgraph
74 
75 /* --- FUNCTION 1 ARGS ------------------------------------------------------ */
76 namespace dynamicgraph {
77 namespace command {
78 
79 template <class E, typename T> struct CommandVoid1 : public Command {
80  typedef boost::function<void(const T &)> function_t;
81 
82  CommandVoid1(E &entity, function_t function, const std::string &docString)
83  : Command(entity, boost::assign::list_of(ValueHelper<T>::TypeID),
84  docString),
85  fptr(function) {}
86 
87 protected:
88  virtual Value doExecute() {
89  assert(getParameterValues().size() == 1);
90  T val = getParameterValues()[0].value();
91  fptr(val);
92  return Value(); // void
93  }
94 
95 private:
96  function_t fptr;
97 };
98 
99 template <class E, typename T>
101 makeCommandVoid1(E &entity, boost::function<void(const T &)> function,
102  // typename CommandVoid1<E,T>::function_t function ,
103  const std::string &docString) {
104  return new CommandVoid1<E, T>(entity, function, docString);
105 }
106 
107 template <class E, typename T>
109 makeCommandVoid1(E &entity,
110  // The following syntaxt don't compile when not specializing
111  // the template arg... why ???
112  boost::function<void(E *, const T &)> function,
113  const std::string &docString) {
114  return new CommandVoid1<E, T>(entity, boost::bind(function, &entity, _1),
115  docString);
116 }
117 
118 template <class E, typename T>
119 CommandVoid1<E, T> *makeCommandVoid1(E &entity, void (E::*function)(const T &),
120  const std::string &docString) {
121  return new CommandVoid1<E, T>(entity, boost::bind(function, &entity, _1),
122  docString);
123  return NULL;
124 }
125 
126 inline std::string docCommandVoid1(const std::string &doc,
127  const std::string &type) {
128  return std::string("\n") + doc + "\n\nInput:\n - A " + type +
129  ".\nVoid return.\n\n";
130 }
131 
132 } // namespace command
133 } // namespace dynamicgraph
134 
135 /* --- FUNCTION 2 ARGS ------------------------------------------------------ */
136 namespace dynamicgraph {
137 namespace command {
138 
139 template <class E, typename T1, typename T2>
140 struct CommandVoid2 : public Command {
141  typedef boost::function<void(const T1 &, const T2 &)> function_t;
142 
143  CommandVoid2(E &entity, function_t function, const std::string &docString)
144  : Command(entity,
145  boost::assign::list_of(ValueHelper<T1>::TypeID)(
147  docString),
148  fptr(function) {}
149 
150 protected:
151  virtual Value doExecute() {
152  assert(getParameterValues().size() == 2);
153  T1 val1 = getParameterValues()[0].value();
154  T2 val2 = getParameterValues()[1].value();
155  fptr(val1, val2);
156  return Value(); // void
157  }
158 
159 private:
160  function_t fptr;
161 };
162 
163 template <class E, typename T1, typename T2>
165 makeCommandVoid2(E &entity,
166  boost::function<void(const T1 &, const T2 &)> function,
167  const std::string &docString) {
168  return new CommandVoid2<E, T1, T2>(entity, function, docString);
169 }
170 
171 template <class E, typename T1, typename T2>
173 makeCommandVoid2(E &entity,
174  // The following syntaxt don't compile when not specializing
175  // the template arg... why ???
176  boost::function<void(E *, const T1 &, const T2 &)> function,
177  const std::string &docString) {
178  return new CommandVoid2<E, T1, T2>(
179  entity, boost::bind(function, &entity, _1, _2), docString);
180 }
181 
182 template <class E, typename T1, typename T2>
184 makeCommandVoid2(E &entity, void (E::*function)(const T1 &, const T2 &),
185  const std::string &docString) {
186  return new CommandVoid2<E, T1, T2>(
187  entity, boost::bind(function, &entity, _1, _2), docString);
188  return NULL;
189 }
190 
191 inline std::string docCommandVoid2(const std::string &doc,
192  const std::string &type1,
193  const std::string &type2) {
194  return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
195  "Input:\n - A " + type2 + ".\n" + "Void return.\n\n");
196 }
197 
198 } // namespace command
199 } // namespace dynamicgraph
200 
201 /* --- FUNCTION 3 ARGS ------------------------------------------------------ */
202 namespace dynamicgraph {
203 namespace command {
204 
205 template <class E, typename T1, typename T2, typename T3>
206 struct CommandVoid3 : public Command {
207  typedef boost::function<void(const T1 &, const T2 &, const T3 &)> function_t;
208 
209  CommandVoid3(E &entity, function_t function, const std::string &docString)
210  : Command(entity,
211  boost::assign::list_of(ValueHelper<T1>::TypeID)(
213  docString),
214  fptr(function) {}
215 
216 protected:
217  virtual Value doExecute() {
218  assert(getParameterValues().size() == 3);
219  T1 val1 = getParameterValues()[0].value();
220  T2 val2 = getParameterValues()[1].value();
221  T3 val3 = getParameterValues()[2].value();
222  fptr(val1, val2, val3);
223  return Value(); // void
224  }
225 
226 private:
227  function_t fptr;
228 };
229 
230 template <class E, typename T1, typename T2, typename T3>
232 makeCommandVoid3(E &entity,
233  typename CommandVoid3<E, T1, T2, T3>::function_t function,
234  const std::string &docString) {
235  return new CommandVoid3<E, T1, T2, T3>(entity, function, docString);
236 }
237 
238 template <class E, typename T1, typename T2, typename T3>
239 CommandVoid3<E, T1, T2, T3> *makeCommandVoid3(
240  E &entity,
241  // The following syntaxt don't compile when not specializing the template
242  // arg... why ???
243  boost::function<void(E *, const T1 &, const T2 &, const T3 &)> function,
244  const std::string &docString) {
245  return new CommandVoid3<E, T1, T2, T3>(
246  entity, boost::bind(function, &entity, _1, _2, _3), docString);
247 }
248 
249 template <class E, typename T1, typename T2, typename T3>
251 makeCommandVoid3(E &entity,
252  void (E::*function)(const T1 &, const T2 &, const T3 &),
253  const std::string &docString) {
254  return new CommandVoid3<E, T1, T2, T3>(
255  entity, boost::bind(function, &entity, _1, _2, _3), docString);
256  return NULL;
257 }
258 
259 inline std::string docCommandVoid3(const std::string &doc,
260  const std::string &type1,
261  const std::string &type2,
262  const std::string &type3) {
263  return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
264  "Input:\n - A " + type2 + ".\n" + "Input:\n - A " + type3 + ".\n" +
265  "Void return.\n\n");
266 }
267 
268 } // namespace command
269 } // namespace dynamicgraph
270 
271 /* --- FUNCTION 4 ARGS ------------------------------------------------------ */
272 namespace dynamicgraph {
273 namespace command {
274 
275 template <class E, typename T1, typename T2, typename T3, typename T4>
276 struct CommandVoid4 : public Command {
277  typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &)>
278  function_t;
279  typedef void (E::*memberFunction_ptr_t)(const T1 &, const T2 &, const T3 &,
280  const T4 &);
281 
282  CommandVoid4(E &entity, function_t function, const std::string &docString)
283  : Command(entity,
284  boost::assign::list_of(ValueHelper<T1>::TypeID)(
287  docString),
288  fptr(function) {}
289 
290 protected:
291  virtual Value doExecute() {
292  assert(getParameterValues().size() == 4);
293  T1 val1 = getParameterValues()[0].value();
294  T2 val2 = getParameterValues()[1].value();
295  T3 val3 = getParameterValues()[2].value();
296  T4 val4 = getParameterValues()[3].value();
297  fptr(val1, val2, val3, val4);
298  return Value(); // void
299  }
300 
301 private:
302  function_t fptr;
303 };
304 
305 template <class E, typename T1, typename T2, typename T3, typename T4>
307 makeCommandVoid4(E &entity,
308  typename CommandVoid4<E, T1, T2, T3, T4>::function_t function,
309  const std::string &docString) {
310  return new CommandVoid4<E, T1, T2, T3, T4>(entity, function, docString);
311 }
312 
313 template <class E, typename T1, typename T2, typename T3, typename T4>
314 CommandVoid4<E, T1, T2, T3, T4> *makeCommandVoid4(
315  E &entity,
316  boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &)>
317  function,
318  const std::string &docString) {
320  entity, boost::bind(function, &entity, _1, _2, _3, _4), docString);
321 }
322 
323 template <class E, typename T1, typename T2, typename T3, typename T4>
324 CommandVoid4<E, T1, T2, T3, T4> *makeCommandVoid4(
325  E &entity,
326  void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &),
327  const std::string &docString) {
329  entity, boost::bind(function, &entity, _1, _2, _3, _4), docString);
330  return NULL;
331 }
332 
333 inline std::string docCommandVoid4(const std::string &doc,
334  const std::string &type1,
335  const std::string &type2,
336  const std::string &type3,
337  const std::string &type4) {
338  return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
339  "Input:\n - A " + type2 + ".\n" + "Input:\n - A " + type3 + ".\n" +
340  "Input:\n - A " + type4 + ".\n" + "Void return.\n\n");
341 }
342 
343 } // namespace command
344 } // namespace dynamicgraph
345 
346 /* --- FUNCTION 5 ARGS ------------------------------------------------------ */
347 namespace dynamicgraph {
348 namespace command {
349 
350 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5>
351 struct CommandVoid5 : public Command {
352  typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &)>
353  function_t;
354  typedef void (E::*memberFunction_ptr_t)(const T1 &, const T2 &, const T3 &,
355  const T4 &, const T5 &);
356 
357  CommandVoid5(E &entity, function_t function, const std::string &docString)
358  : Command(entity,
359  boost::assign::list_of(ValueHelper<T1>::TypeID)(
362  docString),
363  fptr(function) {}
364 
365 protected:
366  virtual Value doExecute() {
367  assert(getParameterValues().size() == 5);
368  T1 val1 = getParameterValues()[0].value();
369  T2 val2 = getParameterValues()[1].value();
370  T3 val3 = getParameterValues()[2].value();
371  T4 val4 = getParameterValues()[3].value();
372  T5 val5 = getParameterValues()[4].value();
373  fptr(val1, val2, val3, val4, val5);
374  return Value(); // void
375  }
376 
377 private:
378  function_t fptr;
379 };
380 
381 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5>
383 makeCommandVoid5(E &entity,
384  typename CommandVoid5<E, T1, T2, T3, T4, T5>::function_t function,
385  const std::string &docString) {
386  return new CommandVoid5<E, T1, T2, T3, T4, T5>(entity, function, docString);
387 }
388 
389 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5>
390 CommandVoid5<E, T1, T2, T3, T4, T5> *makeCommandVoid5(
391  E &entity,
392  boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &)>
393  function,
394  const std::string &docString) {
396  entity, boost::bind(function, &entity, _1, _2, _3, _4, _5), docString);
397 }
398 
399 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5>
400 CommandVoid5<E, T1, T2, T3, T4, T5> *makeCommandVoid5(
401  E &entity,
402  void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &),
403  const std::string &docString) {
405  entity, boost::bind(function, &entity, _1, _2, _3, _4, _5), docString);
406  return NULL;
407 }
408 
409 inline std::string docCommandVoid5(const std::string &doc,
410  const std::string &type1,
411  const std::string &type2,
412  const std::string &type3,
413  const std::string &type4,
414  const std::string &type5) {
415  return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
416  "Input:\n - A " + type2 + ".\n" + "Input:\n - A " + type3 + ".\n" +
417  "Input:\n - A " + type4 + ".\n" + "Input:\n - A " + type5 + ".\n" +
418  "Void return.\n\n");
419 }
420 
421 } // namespace command
422 } // namespace dynamicgraph
423 
424 /* --- FUNCTION 6 ARGS ------------------------------------------------------ */
425 namespace dynamicgraph {
426 namespace command {
427 
428 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
429 struct CommandVoid6 : public Command {
430  typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &)>
431  function_t;
432  typedef void (E::*memberFunction_ptr_t)(const T1 &, const T2 &, const T3 &,
433  const T4 &, const T5 &, const T6 &);
434 
435  CommandVoid6(E &entity, function_t function, const std::string &docString)
436  : Command(entity,
437  boost::assign::list_of(ValueHelper<T1>::TypeID)(
441  docString),
442  fptr(function) {}
443 
444 protected:
445  virtual Value doExecute() {
446  assert(getParameterValues().size() == 6);
447  T1 val1 = getParameterValues()[0].value();
448  T2 val2 = getParameterValues()[1].value();
449  T3 val3 = getParameterValues()[2].value();
450  T4 val4 = getParameterValues()[3].value();
451  T5 val5 = getParameterValues()[4].value();
452  T6 val6 = getParameterValues()[5].value();
453  fptr(val1, val2, val3, val4, val5, val6);
454  return Value(); // void
455  }
456 
457 private:
458  function_t fptr;
459 };
460 
461 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
463 makeCommandVoid6(E &entity,
464  typename CommandVoid6<E, T1, T2, T3, T4, T5, T6>::function_t function,
465  const std::string &docString) {
466  return new CommandVoid6<E, T1, T2, T3, T4, T5, T6>(entity, function, docString);
467 }
468 
469 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
471  E &entity,
472  boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &)>
473  function,
474  const std::string &docString) {
476  entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6), docString);
477 }
478 
479 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
481  E &entity,
482  void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &),
483  const std::string &docString) {
485  entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6), docString);
486  return NULL;
487 }
488 
489 inline std::string docCommandVoid6(const std::string &doc,
490  const std::string &type1,
491  const std::string &type2,
492  const std::string &type3,
493  const std::string &type4,
494  const std::string &type5,
495  const std::string &type6) {
496  return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
497  "Input:\n - A " + type2 + ".\n" + "Input:\n - A " + type3 + ".\n" +
498  "Input:\n - A " + type4 + ".\n" + "Input:\n - A " + type5 + ".\n" +
499  "Input:\n - A " + type6 + ".\n" + "Void return.\n\n");
500 }
501 
502 } // namespace command
503 } // namespace dynamicgraph
504 
505 /* --- FUNCTION 7 ARGS ------------------------------------------------------ */
506 namespace dynamicgraph {
507 namespace command {
508 
509 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
510 struct CommandVoid7 : public Command {
511  typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &)>
512  function_t;
513  typedef void (E::*memberFunction_ptr_t)(const T1 &, const T2 &, const T3 &,
514  const T4 &, const T5 &, const T6 &,
515  const T7 &);
516 
517  CommandVoid7(E &entity, function_t function, const std::string &docString)
518  : Command(entity,
519  boost::assign::list_of(ValueHelper<T1>::TypeID)(
523  docString),
524  fptr(function) {}
525 
526 protected:
527  virtual Value doExecute() {
528  assert(getParameterValues().size() == 7);
529  T1 val1 = getParameterValues()[0].value();
530  T2 val2 = getParameterValues()[1].value();
531  T3 val3 = getParameterValues()[2].value();
532  T4 val4 = getParameterValues()[3].value();
533  T5 val5 = getParameterValues()[4].value();
534  T6 val6 = getParameterValues()[5].value();
535  T7 val7 = getParameterValues()[6].value();
536  fptr(val1, val2, val3, val4, val5, val6, val7);
537  return Value(); // void
538  }
539 
540 private:
541  function_t fptr;
542 };
543 
544 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
546 makeCommandVoid7(E &entity,
547  typename CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7>::function_t function,
548  const std::string &docString) {
549  return new CommandVoid7<E, T1, T2, T3, T4, T5, T6, T7>(entity, function, docString);
550 }
551 
552 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
554  E &entity,
555  boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &)>
556  function,
557  const std::string &docString) {
559  entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7), docString);
560 }
561 
562 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
564  E &entity,
565  void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &),
566  const std::string &docString) {
568  entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7), docString);
569  return NULL;
570 }
571 
572 inline std::string docCommandVoid7(const std::string &doc,
573  const std::string &type1,
574  const std::string &type2,
575  const std::string &type3,
576  const std::string &type4,
577  const std::string &type5,
578  const std::string &type6,
579  const std::string &type7) {
580  return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
581  "Input:\n - A " + type2 + ".\n" + "Input:\n - A " + type3 + ".\n" +
582  "Input:\n - A " + type4 + ".\n" + "Input:\n - A " + type5 + ".\n" +
583  "Input:\n - A " + type6 + ".\n" + "Input:\n - A " + type7 + ".\n" +
584  "Void return.\n\n");
585 }
586 
587 } // namespace command
588 } // namespace dynamicgraph
589 
590 /* --- FUNCTION 8 ARGS ------------------------------------------------------ */
591 namespace dynamicgraph {
592 namespace command {
593 
594 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
595 struct CommandVoid8 : public Command {
596  typedef boost::function<void(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &)>
597  function_t;
598  typedef void (E::*memberFunction_ptr_t)(const T1 &, const T2 &, const T3 &,
599  const T4 &, const T5 &, const T6 &,
600  const T7 &, const T8 &);
601 
602  CommandVoid8(E &entity, function_t function, const std::string &docString)
603  : Command(entity,
604  boost::assign::list_of(ValueHelper<T1>::TypeID)(
609  docString),
610  fptr(function) {}
611 
612 protected:
613  virtual Value doExecute() {
614  assert(getParameterValues().size() == 8);
615  T1 val1 = getParameterValues()[0].value();
616  T2 val2 = getParameterValues()[1].value();
617  T3 val3 = getParameterValues()[2].value();
618  T4 val4 = getParameterValues()[3].value();
619  T5 val5 = getParameterValues()[4].value();
620  T6 val6 = getParameterValues()[5].value();
621  T7 val7 = getParameterValues()[6].value();
622  T8 val8 = getParameterValues()[7].value();
623  fptr(val1, val2, val3, val4, val5, val6, val7, val8);
624  return Value(); // void
625  }
626 
627 private:
628  function_t fptr;
629 };
630 
631 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
633 makeCommandVoid8(E &entity,
634  typename CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8>::function_t function,
635  const std::string &docString) {
636  return new CommandVoid8<E, T1, T2, T3, T4, T5, T6, T7, T8>(entity, function, docString);
637 }
638 
639 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
641  E &entity,
642  boost::function<void(E *, const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &)>
643  function,
644  const std::string &docString) {
646  entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7, _8), docString);
647 }
648 
649 template <class E, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
651  E &entity,
652  void (E::*function)(const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &),
653  const std::string &docString) {
655  entity, boost::bind(function, &entity, _1, _2, _3, _4, _5, _6, _7, _8), docString);
656  return NULL;
657 }
658 
659 inline std::string docCommandVoid8(const std::string &doc,
660  const std::string &type1,
661  const std::string &type2,
662  const std::string &type3,
663  const std::string &type4,
664  const std::string &type5,
665  const std::string &type6,
666  const std::string &type7,
667  const std::string &type8) {
668  return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
669  "Input:\n - A " + type2 + ".\n" + "Input:\n - A " + type3 + ".\n" +
670  "Input:\n - A " + type4 + ".\n" + "Input:\n - A " + type5 + ".\n" +
671  "Input:\n - A " + type6 + ".\n" + "Input:\n - A " + type7 + ".\n" +
672  "Input:\n - A " + type8 + ".\n" + "Void return.\n\n");
673 }
674 
675 } // namespace command
676 } // namespace dynamicgraph
677 
678 /* --- FUNCTION VERBOSE ----------------------------------------------------- */
679 /* This bind a function void f( ostream& ) that display some results into
680  * a string f( void ) that return some string results. */
681 
682 namespace dynamicgraph {
683 namespace command {
684 template <class E> struct CommandVerbose : public Command {
685  typedef boost::function<void(std::ostream &)> function_t;
686 
687  CommandVerbose(E &entity, function_t function, const std::string &docString)
688  : Command(entity, EMPTY_ARG, docString), fptr(function) {}
689 
690 protected:
691  virtual Value doExecute() {
692  assert(getParameterValues().size() == 0);
693  std::ostringstream oss;
694  fptr(oss);
695  return Value(oss.str()); // return string
696  }
697 
698 private:
699  function_t fptr;
700 };
701 
702 template <class E>
704 makeCommandVerbose(E &entity, typename CommandVerbose<E>::function_t function,
705  const std::string &docString) {
706  return new CommandVerbose<E>(entity, function, docString);
707  return NULL;
708 }
709 
710 template <class E>
711 CommandVerbose<E> *makeCommandVerbose(E &entity,
712  void (E::*function)(std::ostream &),
713  const std::string &docString) {
714  return new CommandVerbose<E>(entity, boost::bind(function, &entity, _1),
715  docString);
716  return NULL;
717 }
718 
719 inline std::string docCommandVerbose(const std::string &doc) {
720  return std::string("\n") + doc + "\n\nNo input.\n Return a string.\n\n";
721 }
722 /*************************/
723 /* Template return types */
724 /*************************/
725 
726 template <class E, class ReturnType>
727 struct CommandReturnType0 : public Command {
728  CommandReturnType0(E &entity, boost::function<ReturnType(void)> function,
729  const std::string &docString)
730  : Command(entity, EMPTY_ARG, docString), fptr(function) {}
731 
732 protected:
733  virtual Value doExecute() {
734  assert(getParameterValues().size() == 0);
735  Value res(fptr());
736  return res;
737  }
738 
739 private:
740  boost::function<ReturnType(void)> fptr;
741 };
742 
743 template <class E, class ReturnType>
745 makeCommandReturnType0(E &entity, boost::function<ReturnType(void)> function,
746  const std::string &docString) {
747  return new CommandReturnType0<E, ReturnType>(entity, function, docString);
748 }
749 
750 template <class E, class ReturnType>
752 makeCommandReturnType0(E &entity, boost::function<ReturnType(E *)> function,
753  const std::string &docString) {
755  entity, boost::bind(function, &entity), docString);
756 }
757 
758 template <class E, class ReturnType>
760 makeCommandReturnType0(E &entity, ReturnType (E::*function)(void),
761  const std::string &docString) {
763  entity, boost::bind(function, &entity), docString);
764 }
765 
766 template <typename ReturnType>
767 inline std::string
768 docCommandReturnType0(const std::string &doc,
769  const std::string & /* return_type */) {
770  return std::string("\n") + doc + "\n\nNo input.\n" +
771  typeid(ReturnType).name() + " return.\n\n";
772 }
773 
774 } // namespace command
775 } // namespace dynamicgraph
776 
777 /* --- FUNCTION 1 ARGS ------------------------------------------------------ */
778 namespace dynamicgraph {
779 namespace command {
780 
781 template <class E, typename ReturnType, typename T>
782 struct CommandReturnType1 : public Command {
783  typedef boost::function<ReturnType(const T &)> function_t;
784 
785  CommandReturnType1(E &entity, function_t function,
786  const std::string &docString)
787  : Command(entity, boost::assign::list_of(ValueHelper<T>::TypeID),
788  docString),
789  fptr(function) {}
790 
791 protected:
792  virtual Value doExecute() {
793  assert(getParameterValues().size() == 1);
794  T val = getParameterValues()[0].value();
795  Value res(fptr(val));
796  return res;
797  }
798 
799 private:
800  function_t fptr;
801 };
802 
803 template <class E, typename ReturnType, typename T>
805 makeCommandReturnType1(E &entity,
806  boost::function<ReturnType(const T &)> function,
807  const std::string &docString) {
808  return new CommandReturnType1<E, ReturnType, T>(entity, function, docString);
809 }
810 
811 template <class E, typename ReturnType, typename T>
813 makeCommandReturnType1(E &entity,
814  // The following syntaxt don't compile when not
815  // specializing the template arg... why ???
816  boost::function<ReturnType(E *, const T &)> function,
817  const std::string &docString) {
819  entity, boost::bind(function, &entity, _1), docString);
820 }
821 
822 template <class E, typename ReturnType, typename T>
824 makeCommandReturnType1(E &entity, ReturnType (E::*function)(const T &),
825  const std::string &docString) {
827  entity, boost::bind(function, &entity, _1), docString);
828  return NULL;
829 }
830 
831 template <typename ReturnType>
832 inline std::string docCommandReturnType1(const std::string &doc,
833  const std::string &type) {
834  return std::string("\n") + doc + "\n\nInput:\n - A " + type + ".\n" +
835  typeid(ReturnType).name() + "return.\n\n";
836 }
837 
838 } // namespace command
839 } // namespace dynamicgraph
840 
841 /*********** FUNCTION 2 Arguments ************************/
842 namespace dynamicgraph {
843 namespace command {
844 
845 template <class E, typename ReturnType, typename T1, typename T2>
846 struct CommandReturnType2 : public Command {
847  typedef boost::function<ReturnType(const T1 &, const T2 &)> function_t;
848 
849  CommandReturnType2(E &entity, function_t function,
850  const std::string &docString)
851  : Command(entity,
852  boost::assign::list_of(ValueHelper<T1>::TypeID)(
854  docString),
855  fptr(function) {}
856 
857 protected:
858  virtual Value doExecute() {
859  assert(getParameterValues().size() == 2);
860  T1 val1 = getParameterValues()[0].value();
861  T2 val2 = getParameterValues()[1].value();
862  Value res(fptr(val1, val2));
863  return res;
864  }
865 
866 private:
867  function_t fptr;
868 };
869 
870 template <class E, typename ReturnType, typename T1, typename T2>
871 CommandReturnType2<E, ReturnType, T1, T2> *makeCommandReturnType2(
872  E &entity, boost::function<ReturnType(const T1 &, const T2 &)> function,
873  const std::string &docString) {
874  return new CommandReturnType2<E, ReturnType, T1, T2>(entity, function,
875  docString);
876 }
877 
878 template <class E, typename ReturnType, typename T1, typename T2>
879 CommandReturnType2<E, ReturnType, T1, T2> *makeCommandReturnType2(
880  E &entity,
881  // The following syntaxt don't compile when not specializing the template
882  // arg... why ???
883  boost::function<ReturnType(E *, const T1 &, const T2 &)> function,
884  const std::string &docString) {
886  entity, boost::bind(function, &entity, _1, _2), docString);
887 }
888 
889 template <class E, typename ReturnType, typename T1, typename T2>
891 makeCommandReturnType2(E &entity,
892  ReturnType (E::*function)(const T1 &, const T2 &),
893  const std::string &docString) {
895  entity, boost::bind(function, &entity, _1, _2), docString);
896  return NULL;
897 }
898 
899 template <typename ReturnType>
900 inline std::string docCommandReturnType2(const std::string &doc,
901  const std::string &type1,
902  const std::string &type2) {
903  return (std::string("\n") + doc + "\n\n" + "Input:\n - A " + type1 + ".\n" +
904  "Input:\n - A " + type2 + ".\n" +
905  "ReturnType:\n - Returns:" + typeid(ReturnType).name() + +".\n\n");
906 }
907 
908 } // namespace command
909 } // namespace dynamicgraph
910 
911 #endif // __dg_command_bind_h__
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:217
Command(Entity &entity, const std::vector< Value::Type > &valueTypes, const std::string &docstring)
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:613
This class implements a variant design pattern to handle basic types in Command.
Definition: value.h:46
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:88
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:792
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:445
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:691
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:291
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:151
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:527
const std::vector< Value > & getParameterValues() const
Get parameter values.
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:858
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:38
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:366
virtual Value doExecute()
Specific action performed by the command.
Definition: command-bind.h:733