Orocos Real-Time Toolkit  2.8.3
BindStorage.hpp
Go to the documentation of this file.
1 /***************************************************************************
2  tag: FMTC do nov 2 13:06:12 CET 2006 BindStorage.hpp
3 
4  BindStorage.hpp - description
5  -------------------
6  begin : do november 02 2006
7  copyright : (C) 2006 FMTC
8  email : peter.soetens@fmtc.be
9 
10  ***************************************************************************
11  * This library is free software; you can redistribute it and/or *
12  * modify it under the terms of the GNU General Public *
13  * License as published by the Free Software Foundation; *
14  * version 2 of the License. *
15  * *
16  * As a special exception, you may use this file as part of a free *
17  * software library without restriction. Specifically, if other files *
18  * instantiate templates or use macros or inline functions from this *
19  * file, or you compile this file and link it with other files to *
20  * produce an executable, this file does not by itself cause the *
21  * resulting executable to be covered by the GNU General Public *
22  * License. This exception does not however invalidate any other *
23  * reasons why the executable file might be covered by the GNU General *
24  * Public License. *
25  * *
26  * This library is distributed in the hope that it will be useful, *
27  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
28  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
29  * Lesser General Public License for more details. *
30  * *
31  * You should have received a copy of the GNU General Public *
32  * License along with this library; if not, write to the Free Software *
33  * Foundation, Inc., 59 Temple Place, *
34  * Suite 330, Boston, MA 02111-1307 USA *
35  * *
36  ***************************************************************************/
37 
38 
39 #ifndef ORO_TASK_BIND_STORAGE_HPP
40 #define ORO_TASK_BIND_STORAGE_HPP
41 
42 #include <boost/function.hpp>
43 #include <boost/type_traits/function_traits.hpp>
44 #include <boost/bind.hpp>
45 #include <boost/fusion/include/vector.hpp>
46 #include <boost/fusion/include/filter_if.hpp>
47 #include "NA.hpp"
48 #include "../Logger.hpp"
49 
50 #ifdef ORO_SIGNALLING_OPERATIONS
51 #include "Signal.hpp"
52 #endif
53 
54 namespace RTT
55 {
56  namespace internal
57  {
58  namespace bf=boost::fusion;
59  namespace mpl=boost::mpl;
64  template<class T>
65  struct AStore
66  {
67  T arg;
68  AStore() : arg() {}
69  AStore(T t) : arg(t) {}
70  AStore(AStore const& o) : arg(o.arg) {}
71 
72  T& get() { return arg; }
73  void operator()(T a) { arg = a; }
74  operator T() { return arg;}
75  };
76 
77  template<class T>
78  struct AStore<T&>
79  {
80  T* arg;
81  AStore() : arg( &NA<T&>::na() ) {}
82  AStore(T& t) : arg(&t) {}
83  AStore(AStore const& o) : arg(o.arg) {}
84 
85  T& get() { return *arg; }
86  void operator()(T& a) { arg = &a; }
87  operator T&() { return *arg;}
88  };
89 
90  template<class T>
91  std::ostream& operator<<(std::ostream& o, AStore<T>& a) { o << "aarg:"<<a.get(); return o;}
92 
93  template<>
94  struct RStore<void> {
95  bool executed;
96  bool error;
97  RStore() : executed(false), error(false) {}
98 
99  void checkError() const {
100  if(error) throw std::runtime_error("Unable to complete the operation call. The called operation has thrown an exception");
101  }
102 
103  bool isError() const {
104  return error;
105  }
106 
107  bool isExecuted() const {
108  return executed;
109  }
110 
111  template<class F>
112  void exec(F f) {
113  error = false;
114  try{
115  f();
116  } catch (std::exception& e) {
117  log(Error) << "Exception raised while executing an operation : " << e.what() << endlog();
118  error = true;
119  } catch (...) {
120  log(Error) << "Unknown exception raised while executing an operation." << endlog();
121  error = true;
122  }
123  executed = true;
124  }
125 
126  void result() { checkError(); return; }
127  };
128 
129 
137  template<class T>
138  struct RStore : public RStore<void> {
139  T arg;
140  RStore() : arg() {}
141 
142  T& result() { checkError(); return arg; }
143  operator T&() { return arg;}
144 
151  template<class F>
152  void exec(F f) {
153  error = false;
154  try{
155  arg = f();
156  } catch (std::exception& e) {
157  log(Error) << "Exception raised while executing an operation : " << e.what() << endlog();
158  error = true;
159  } catch (...) {
160  log(Error) << "Unknown exception raised while executing an operation." << endlog();
161  error = true;
162  }
163  executed = true;
164  }
165  };
166 
167  template<class T>
168  struct RStore<T&> : public RStore<void>
169  {
170  T* arg;
171  RStore() : arg() {}
172 
173  template<class F>
174  void exec(F f) {
175  error = false;
176  try{
177  arg = &f();
178  } catch (std::exception& e) {
179  log(Error) << "Exception raised while executing an operation : " << e.what() << endlog();
180  error = true;
181  } catch (...) {
182  log(Error) << "Unknown exception raised while executing an operation." << endlog();
183  error = true;
184  }
185  executed = true;
186  }
187 
188  //bool operator()() { return executed; }
189 
190  T& result() { checkError(); return *arg; }
191  operator T&() { checkError(); return *arg;}
192  };
193 
194  template<class T>
195  struct RStore<const T> : public RStore<void> {
196  T arg;
197  RStore() : arg() {}
198 
199  T& result() { checkError(); return arg; }
200  operator T&() { checkError(); return arg;}
201 
208  template<class F>
209  void exec(F f) {
210  error = false;
211  try{
212  arg = f();
213  } catch (std::exception& e) {
214  log(Error) << "Exception raised while executing an operation : " << e.what() << endlog();
215  error = true;
216  } catch(...) {
217  log(Error) << "Unknown exception raised while executing an operation." << endlog();
218  error = true;
219  }
220  executed = true;
221  }
222 
223  };
224 
225  template<class T>
226  std::ostream& operator<<(std::ostream& o, RStore<T>& a) { o << "rarg:"<<a.result(); return o;}
227 
235  template<class Arg>
236  struct is_arg_return : public mpl::false_ {};
237 
238  template<class T>
239  struct is_arg_return<AStore<T&> > : public mpl::true_
240  {};
241 
242  template<class T>
243  struct is_arg_return<AStore<T const &> > : public mpl::false_
244  {};
245 
246  template<>
247  struct is_arg_return<RStore<void> > : public mpl::false_
248  {};
249 
250  template<class T>
251  struct is_arg_return<RStore<T> > : public mpl::true_
252  {};
253 
257  template<class Arg>
258  struct is_out_arg : public mpl::false_ {};
259 
260  template<class T>
261  struct is_out_arg<AStore<T&> > : public mpl::true_
262  {};
263 
264  template<class T>
265  struct is_out_arg<AStore<T const &> > : public mpl::false_
266  {};
267 
268  template<int, class T>
270 
275  template<class ToBind>
276  struct BindStorageImpl<0, ToBind>
277  {
278  typedef typename boost::function_traits<ToBind>::result_type result_type;
280 
281  // stores the original function pointer
282  boost::function<ToBind> mmeth;
284  // the list of all our storage.
285  bf::vector< RStore<result_type>&> vStore;
286 #ifdef ORO_SIGNALLING_OPERATIONS
287  typename Signal<ToBind>::shared_ptr msig;
288 #endif
289 
290  BindStorageImpl() : vStore(boost::ref(retv)) {}
291  BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv)
293  , msig(orig.msig)
294 #endif
295  {}
296 
297  void exec() {
298 #ifdef ORO_SIGNALLING_OPERATIONS
299  if (msig) msig->emit();
300 #endif
301  if (mmeth)
302  retv.exec( mmeth );
303  else
304  retv.executed = true;
305  }
306  };
307 
311  template<class ToBind>
312  struct BindStorageImpl<1, ToBind>
313  {
314  typedef typename boost::function_traits<ToBind>::result_type result_type;
315  typedef typename boost::function_traits<ToBind>::arg1_type arg1_type;
317 
318  // stores the original function pointer, supplied by the user.
319  boost::function<ToBind> mmeth;
320  // Store the argument.
323  // the list of all our storage.
324  bf::vector< RStore<result_type>&, AStore<arg1_type>& > vStore;
325 #ifdef ORO_SIGNALLING_OPERATIONS
326  typename Signal<ToBind>::shared_ptr msig;
327 #endif
328 
329  BindStorageImpl() : vStore(retv,a1) {}
330  BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1)
332  , msig(orig.msig)
333 #endif
334  {}
335  void store(arg1_type t1) { a1(t1); }
336  void exec() {
337 #ifdef ORO_SIGNALLING_OPERATIONS
338  if (msig) (*msig)(a1.get());
339 #endif
340  if (mmeth)
341  retv.exec( boost::bind(mmeth, boost::ref(a1.get()) ) );
342  else
343  retv.executed = true;
344  }
345 
346  };
347 
348  template<class ToBind>
349  struct BindStorageImpl<2, ToBind>
350  {
351  typedef typename boost::function_traits<ToBind>::result_type result_type;
352  typedef typename boost::function_traits<ToBind>::arg1_type arg1_type;
353  typedef typename boost::function_traits<ToBind>::arg2_type arg2_type;
355 
356  // stores the original function pointer
357  boost::function<ToBind> mmeth;
358  // Store the arguments.
362  // the list of all our storage.
363  bf::vector< RStore<result_type>&, AStore<arg1_type>&, AStore<arg2_type>& > vStore;
364 #ifdef ORO_SIGNALLING_OPERATIONS
365  typename Signal<ToBind>::shared_ptr msig;
366 #endif
367 
368  BindStorageImpl() : vStore(retv,a1,a2) {}
369  BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2)
371  , msig(orig.msig)
372 #endif
373  {}
374 
375  void store(arg1_type t1, arg2_type t2) { a1(t1); a2(t2); }
376  void exec() {
377 #ifdef ORO_SIGNALLING_OPERATIONS
378  if (msig) (*msig)(a1.get(), a2.get());
379 #endif
380  if (mmeth)
381  retv.exec( boost::bind(mmeth, boost::ref(a1.get()), boost::ref(a2.get()) ) );
382  else
383  retv.executed = true;
384  }
385 
386  };
387 
388  template<class ToBind>
389  struct BindStorageImpl<3, ToBind>
390  {
391  typedef typename boost::function_traits<ToBind>::result_type result_type;
392  typedef typename boost::function_traits<ToBind>::arg1_type arg1_type;
393  typedef typename boost::function_traits<ToBind>::arg2_type arg2_type;
394  typedef typename boost::function_traits<ToBind>::arg3_type arg3_type;
396 
397  // stores the original function pointer
398  boost::function<ToBind> mmeth;
399  // Store the arguments.
404  // the list of all our storage.
405  bf::vector< RStore<result_type>&, AStore<arg1_type>&, AStore<arg2_type>&, AStore<arg3_type>& > vStore;
406 #ifdef ORO_SIGNALLING_OPERATIONS
407  typename Signal<ToBind>::shared_ptr msig;
408 #endif
409 
410  BindStorageImpl() : vStore(retv,a1,a2,a3) {}
411  BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2,a3)
413  , msig(orig.msig)
414 #endif
415  {}
416 
417  void store(arg1_type t1, arg2_type t2, arg3_type t3) { a1(t1); a2(t2); a3(t3); }
418  void exec() {
419 #ifdef ORO_SIGNALLING_OPERATIONS
420  if (msig) (*msig)(a1.get(), a2.get(), a3.get());
421 #endif
422  if (mmeth)
423  retv.exec( boost::bind(mmeth, boost::ref(a1.get()), boost::ref(a2.get()), boost::ref(a3.get()) ) );
424  else
425  retv.executed = true;
426  }
427  };
428 
429  template<class ToBind>
430  struct BindStorageImpl<4, ToBind>
431  {
432  typedef typename boost::function_traits<ToBind>::result_type result_type;
433  typedef typename boost::function_traits<ToBind>::arg1_type arg1_type;
434  typedef typename boost::function_traits<ToBind>::arg2_type arg2_type;
435  typedef typename boost::function_traits<ToBind>::arg3_type arg3_type;
436  typedef typename boost::function_traits<ToBind>::arg4_type arg4_type;
438 
439  // stores the original function pointer
440  boost::function<ToBind> mmeth;
441  // Store the arguments.
447  // the list of all our storage.
449 #ifdef ORO_SIGNALLING_OPERATIONS
450  typename Signal<ToBind>::shared_ptr msig;
451 #endif
452 
453  BindStorageImpl() : vStore(retv,a1,a2,a3,a4) {}
454  BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2,a3,a4)
456  , msig(orig.msig)
457 #endif
458  {}
459 
460  void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4) { a1(t1); a2(t2); a3(t3); a4(t4); }
461  void exec() {
462 #ifdef ORO_SIGNALLING_OPERATIONS
463  if (msig) (*msig)(a1.get(), a2.get(), a3.get(), a4.get());
464 #endif
465  if (mmeth)
466  retv.exec( boost::bind( mmeth, boost::ref(a1.get()), boost::ref(a2.get()), boost::ref(a3.get()), boost::ref(a4.get()) ) );
467  else
468  retv.executed = true;
469  }
470  };
471 
472  template<class ToBind>
473  struct BindStorageImpl<5, ToBind>
474  {
475  typedef typename boost::function_traits<ToBind>::result_type result_type;
476  typedef typename boost::function_traits<ToBind>::arg1_type arg1_type;
477  typedef typename boost::function_traits<ToBind>::arg2_type arg2_type;
478  typedef typename boost::function_traits<ToBind>::arg3_type arg3_type;
479  typedef typename boost::function_traits<ToBind>::arg4_type arg4_type;
480  typedef typename boost::function_traits<ToBind>::arg5_type arg5_type;
482 
483  // stores the original function pointer
484  boost::function<ToBind> mmeth;
485  // Store the arguments.
492  // the list of all our storage.
494 #ifdef ORO_SIGNALLING_OPERATIONS
495  typename Signal<ToBind>::shared_ptr msig;
496 #endif
497 
498  BindStorageImpl() : vStore(retv,a1,a2,a3,a4,a5) {}
499  BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2,a3,a4,a5)
501  , msig(orig.msig)
502 #endif
503  {}
504 
505  void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5) { a1(t1); a2(t2); a3(t3); a4(t4); a5(t5);}
506  void exec() {
507 #ifdef ORO_SIGNALLING_OPERATIONS
508  if (msig) (*msig)(a1.get(), a2.get(), a3.get(), a4.get(), a5.get());
509 #endif
510  if (mmeth)
511  retv.exec( boost::bind( mmeth, boost::ref(a1.get()), boost::ref(a2.get()), boost::ref(a3.get()), boost::ref(a4.get()), boost::ref(a5.get()) ) );
512  else
513  retv.executed = true;
514  }
515  };
516 
517  template<class ToBind>
518  struct BindStorageImpl<6, ToBind>
519  {
520  typedef typename boost::function_traits<ToBind>::result_type result_type;
521  typedef typename boost::function_traits<ToBind>::arg1_type arg1_type;
522  typedef typename boost::function_traits<ToBind>::arg2_type arg2_type;
523  typedef typename boost::function_traits<ToBind>::arg3_type arg3_type;
524  typedef typename boost::function_traits<ToBind>::arg4_type arg4_type;
525  typedef typename boost::function_traits<ToBind>::arg5_type arg5_type;
526  typedef typename boost::function_traits<ToBind>::arg6_type arg6_type;
528 
529  // stores the original function pointer
530  boost::function<ToBind> mmeth;
531  // Store the arguments.
539  // the list of all our storage.
541 #ifdef ORO_SIGNALLING_OPERATIONS
542  typename Signal<ToBind>::shared_ptr msig;
543 #endif
544 
545  BindStorageImpl() : vStore(retv,a1,a2,a3,a4,a5,a6) {}
546  BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2,a3,a4,a5,a6)
548  , msig(orig.msig)
549 #endif
550  {}
551 
552  void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5, arg6_type t6) { a1(t1); a2(t2); a3(t3); a4(t4); a5(t5); a6(t6);}
553  void exec() {
554 #ifdef ORO_SIGNALLING_OPERATIONS
555  if (msig) (*msig)(a1.get(), a2.get(), a3.get(), a4.get(), a5.get(), a6.get());
556 #endif
557  if (mmeth)
558  retv.exec( boost::bind( mmeth, boost::ref(a1.get()), boost::ref(a2.get()), boost::ref(a3.get()), boost::ref(a4.get()), boost::ref(a5.get()), boost::ref(a6.get()) ) );
559  else
560  retv.executed = true;
561  }
562  };
563 
564  template<class ToBind>
565  struct BindStorageImpl<7, ToBind>
566  {
567  typedef typename boost::function_traits<ToBind>::result_type result_type;
568  typedef typename boost::function_traits<ToBind>::arg1_type arg1_type;
569  typedef typename boost::function_traits<ToBind>::arg2_type arg2_type;
570  typedef typename boost::function_traits<ToBind>::arg3_type arg3_type;
571  typedef typename boost::function_traits<ToBind>::arg4_type arg4_type;
572  typedef typename boost::function_traits<ToBind>::arg5_type arg5_type;
573  typedef typename boost::function_traits<ToBind>::arg6_type arg6_type;
574  typedef typename boost::function_traits<ToBind>::arg7_type arg7_type;
576 
577  // stores the original function pointer
578  boost::function<ToBind> mmeth;
579  // Store the arguments.
588  // the list of all our storage.
590 #ifdef ORO_SIGNALLING_OPERATIONS
591  typename Signal<ToBind>::shared_ptr msig;
592 #endif
593 
594  BindStorageImpl() : vStore(retv,a1,a2,a3,a4,a5,a6,a7) {}
595  BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2,a3,a4,a5,a6,a7)
597  , msig(orig.msig)
598 #endif
599  {}
600 
601  void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5, arg6_type t6, arg7_type t7) { a1(t1); a2(t2); a3(t3); a4(t4); a5(t5); a6(t6); a7(t7);}
602  void exec() {
603 #ifdef ORO_SIGNALLING_OPERATIONS
604  if (msig) (*msig)(a1.get(), a2.get(), a3.get(), a4.get(), a5.get(), a6.get(), a7.get());
605 #endif
606  if (mmeth)
607  retv.exec( boost::bind( mmeth, boost::ref(a1.get()), boost::ref(a2.get()), boost::ref(a3.get()), boost::ref(a4.get()), boost::ref(a5.get()), boost::ref(a6.get()), boost::ref(a7.get()) ) );
608  else
609  retv.executed = true;
610  }
611  };
612 
613 
632  template<class ToBind>
633  struct BindStorage
634  : public BindStorageImpl<boost::function_traits<ToBind>::arity, ToBind>
635  {
636  };
637  }
638 }
639 #endif
bf::vector< RStore< result_type > &, AStore< arg1_type > & > vStore
bf::vector< RStore< result_type > &, AStore< arg1_type > &, AStore< arg2_type > &, AStore< arg3_type > &, AStore< arg4_type > &, AStore< arg5_type > & > vStore
boost::function_traits< ToBind >::arg2_type arg2_type
boost::function_traits< ToBind >::arg5_type arg5_type
boost::function_traits< ToBind >::arg5_type arg5_type
BindStorageImpl(const BindStorageImpl &orig)
boost::function_traits< ToBind >::result_type result_type
boost::function_traits< ToBind >::arg3_type arg3_type
boost::function_traits< ToBind >::arg1_type arg1_type
void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5, arg6_type t6, arg7_type t7)
boost::function_traits< ToBind >::arg1_type arg1_type
boost::function_traits< ToBind >::result_type result_type
bf::vector< RStore< result_type > &, AStore< arg1_type > &, AStore< arg2_type > &, AStore< arg3_type > &, AStore< arg4_type > & > vStore
void store(arg1_type t1, arg2_type t2, arg3_type t3)
Store a bound argument which may be a reference, const reference or any other type.
Definition: BindStorage.hpp:65
bf::vector< RStore< result_type > &, AStore< arg1_type > &, AStore< arg2_type > & > vStore
void exec(F f)
Stores the result of a function.
bf::vector< RStore< result_type > &, AStore< arg1_type > &, AStore< arg2_type > &, AStore< arg3_type > & > vStore
boost::function_traits< ToBind >::result_type result_type
boost::function_traits< ToBind >::arg2_type arg2_type
bf::vector< RStore< result_type > & > vStore
void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5, arg6_type t6)
boost::function_traits< ToBind >::arg6_type arg6_type
boost::function_traits< ToBind >::arg2_type arg2_type
BindStorageImpl(const BindStorageImpl &orig)
boost::function_traits< ToBind >::arg4_type arg4_type
boost::function_traits< ToBind >::arg4_type arg4_type
boost::function_traits< ToBind >::arg3_type arg3_type
boost::function_traits< ToBind >::result_type result_type
bf::vector< RStore< result_type > &, AStore< arg1_type > &, AStore< arg2_type > &, AStore< arg3_type > &, AStore< arg4_type > &, AStore< arg5_type > &, AStore< arg6_type > & > vStore
BindStorageImpl(const BindStorageImpl &orig)
boost::function_traits< ToBind >::arg1_type arg1_type
Store a return value which may be a void, reference, const reference or any other type...
boost::function_traits< ToBind >::result_type result_type
BindStorageImpl(const BindStorageImpl &orig)
A helper-class for the Command implementation which stores the command and collition function objects...
void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4)
#define ORO_SIGNALLING_OPERATIONS
boost::function_traits< ToBind >::arg7_type arg7_type
void store(arg1_type t1, arg2_type t2)
boost::function_traits< ToBind >::arg1_type arg1_type
boost::function_traits< ToBind >::arg3_type arg3_type
boost::shared_ptr< Signal< Signature, TSlotFunction > > shared_ptr
Definition: Signal.hpp:215
bf::vector< RStore< result_type > &, AStore< arg1_type > &, AStore< arg2_type > &, AStore< arg3_type > &, AStore< arg4_type > &, AStore< arg5_type > &, AStore< arg6_type > &, AStore< arg7_type > & > vStore
boost::function_traits< ToBind >::arg1_type arg1_type
BindStorageImpl(const BindStorageImpl &orig)
void exec(F f)
Stores the result of a function.
boost::function_traits< ToBind >::arg5_type arg5_type
boost::function_traits< ToBind >::arg4_type arg4_type
Outargs are of type AStore and contain a pure reference.
This class is used to return a &#39;default&#39; value when no value is available (&#39;Not Available&#39;).
Definition: NA.hpp:53
boost::function_traits< ToBind >::arg1_type arg1_type
boost::function_traits< ToBind >::arg6_type arg6_type
BindStorageImpl(const BindStorageImpl &orig)
void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4, arg5_type t5)
boost::function_traits< ToBind >::arg2_type arg2_type
BindStorageImpl(const BindStorageImpl &orig)
AStore(AStore const &o)
Definition: BindStorage.hpp:70
boost::function_traits< ToBind >::arg4_type arg4_type
boost::function_traits< ToBind >::arg1_type arg1_type
boost::function_traits< ToBind >::arg3_type arg3_type
Contains TaskContext, Activity, OperationCaller, Operation, Property, InputPort, OutputPort, Attribute.
Definition: Activity.cpp:51
boost::function_traits< ToBind >::result_type result_type
This helper struct is required to filter out the AStore elements that don&#39;t need to be returned to th...
boost::function_traits< ToBind >::result_type result_type
boost::function_traits< ToBind >::arg3_type arg3_type
boost::function_traits< ToBind >::arg2_type arg2_type
boost::function_traits< ToBind >::result_type result_type
boost::function_traits< ToBind >::arg2_type arg2_type
BindStorageImpl(const BindStorageImpl &orig)