|
Orocos Real-Time Toolkit
2.6.0
|
00001 /*************************************************************************** 00002 tag: FMTC do nov 2 13:06:12 CET 2006 BindStorage.hpp 00003 00004 BindStorage.hpp - description 00005 ------------------- 00006 begin : do november 02 2006 00007 copyright : (C) 2006 FMTC 00008 email : peter.soetens@fmtc.be 00009 00010 *************************************************************************** 00011 * This library is free software; you can redistribute it and/or * 00012 * modify it under the terms of the GNU General Public * 00013 * License as published by the Free Software Foundation; * 00014 * version 2 of the License. * 00015 * * 00016 * As a special exception, you may use this file as part of a free * 00017 * software library without restriction. Specifically, if other files * 00018 * instantiate templates or use macros or inline functions from this * 00019 * file, or you compile this file and link it with other files to * 00020 * produce an executable, this file does not by itself cause the * 00021 * resulting executable to be covered by the GNU General Public * 00022 * License. This exception does not however invalidate any other * 00023 * reasons why the executable file might be covered by the GNU General * 00024 * Public License. * 00025 * * 00026 * This library is distributed in the hope that it will be useful, * 00027 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00028 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00029 * Lesser General Public License for more details. * 00030 * * 00031 * You should have received a copy of the GNU General Public * 00032 * License along with this library; if not, write to the Free Software * 00033 * Foundation, Inc., 59 Temple Place, * 00034 * Suite 330, Boston, MA 02111-1307 USA * 00035 * * 00036 ***************************************************************************/ 00037 00038 00039 #ifndef ORO_TASK_BIND_STORAGE_HPP 00040 #define ORO_TASK_BIND_STORAGE_HPP 00041 00042 #include <boost/function.hpp> 00043 #include <boost/type_traits/function_traits.hpp> 00044 #include <boost/bind.hpp> 00045 #include <boost/fusion/include/vector.hpp> 00046 #include <boost/fusion/include/filter_if.hpp> 00047 #include "NA.hpp" 00048 00049 #ifdef ORO_SIGNALLING_OPERATIONS 00050 #include "Signal.hpp" 00051 #endif 00052 00053 namespace RTT 00054 { 00055 namespace internal 00056 { 00057 namespace bf=boost::fusion; 00058 namespace mpl=boost::mpl; 00063 template<class T> 00064 struct AStore 00065 { 00066 T arg; 00067 AStore() : arg() {} 00068 AStore(T t) : arg(t) {} 00069 AStore(AStore const& o) : arg(o.arg) {} 00070 00071 T& get() { return arg; } 00072 void operator()(T a) { arg = a; } 00073 operator T() { return arg;} 00074 }; 00075 00076 template<class T> 00077 struct AStore<T&> 00078 { 00079 T* arg; 00080 AStore() : arg( &NA<T&>::na() ) {} 00081 AStore(T& t) : arg(&t) {} 00082 AStore(AStore const& o) : arg(o.arg) {} 00083 00084 T& get() { return *arg; } 00085 void operator()(T& a) { arg = &a; } 00086 operator T&() { return *arg;} 00087 }; 00088 00089 template<class T> 00090 std::ostream& operator<<(std::ostream& o, AStore<T>& a) { o << "aarg:"<<a.get(); return o;} 00091 00092 template<> 00093 struct RStore<void> { 00094 bool executed; 00095 bool error; 00096 RStore() : executed(false), error(false) {} 00097 00098 void checkError() const { 00099 if(error) throw std::runtime_error("Unable to complete the operation call. The called operation has thrown an exception"); 00100 } 00101 00102 bool isError() const { 00103 return error; 00104 } 00105 00106 bool isExecuted() const { 00107 return executed; 00108 } 00109 00110 template<class F> 00111 void exec(F f) { 00112 error = false; 00113 try{ 00114 f(); 00115 } catch (std::exception& e) { 00116 log(Error) << "Exception raised while executing an operation : " << e.what() << endlog(); 00117 error = true; 00118 } catch (...) { 00119 log(Error) << "Unknown exception raised while executing an operation." << endlog(); 00120 error = true; 00121 } 00122 executed = true; 00123 } 00124 00125 void result() { checkError(); return; } 00126 }; 00127 00128 00136 template<class T> 00137 struct RStore : public RStore<void> { 00138 T arg; 00139 RStore() : arg() {} 00140 00141 T& result() { checkError(); return arg; } 00142 operator T&() { return arg;} 00143 00150 template<class F> 00151 void exec(F f) { 00152 error = false; 00153 try{ 00154 arg = f(); 00155 } catch (std::exception& e) { 00156 log(Error) << "Exception raised while executing an operation : " << e.what() << endlog(); 00157 error = true; 00158 } catch (...) { 00159 log(Error) << "Unknown exception raised while executing an operation." << endlog(); 00160 error = true; 00161 } 00162 executed = true; 00163 } 00164 }; 00165 00166 template<class T> 00167 struct RStore<T&> : public RStore<void> 00168 { 00169 T* arg; 00170 RStore() : arg() {} 00171 00172 template<class F> 00173 void exec(F f) { 00174 error = false; 00175 try{ 00176 arg = &f(); 00177 } catch (std::exception& e) { 00178 log(Error) << "Exception raised while executing an operation : " << e.what() << endlog(); 00179 error = true; 00180 } catch (...) { 00181 log(Error) << "Unknown exception raised while executing an operation." << endlog(); 00182 error = true; 00183 } 00184 executed = true; 00185 } 00186 00187 //bool operator()() { return executed; } 00188 00189 T& result() { checkError(); return *arg; } 00190 operator T&() { checkError(); return *arg;} 00191 }; 00192 00193 template<class T> 00194 struct RStore<const T> : public RStore<void> { 00195 T arg; 00196 RStore() : arg() {} 00197 00198 T& result() { checkError(); return arg; } 00199 operator T&() { checkError(); return arg;} 00200 00207 template<class F> 00208 void exec(F f) { 00209 error = false; 00210 try{ 00211 arg = f(); 00212 } catch (std::exception& e) { 00213 log(Error) << "Exception raised while executing an operation : " << e.what() << endlog(); 00214 error = true; 00215 } catch(...) { 00216 log(Error) << "Unknown exception raised while executing an operation." << endlog(); 00217 error = true; 00218 } 00219 executed = true; 00220 } 00221 00222 }; 00223 00224 template<class T> 00225 std::ostream& operator<<(std::ostream& o, RStore<T>& a) { o << "rarg:"<<a.result(); return o;} 00226 00234 template<class Arg> 00235 struct is_arg_return : public mpl::false_ {}; 00236 00237 template<class T> 00238 struct is_arg_return<AStore<T&> > : public mpl::true_ 00239 {}; 00240 00241 template<class T> 00242 struct is_arg_return<AStore<T const &> > : public mpl::false_ 00243 {}; 00244 00245 template<> 00246 struct is_arg_return<RStore<void> > : public mpl::false_ 00247 {}; 00248 00249 template<class T> 00250 struct is_arg_return<RStore<T> > : public mpl::true_ 00251 {}; 00252 00256 template<class Arg> 00257 struct is_out_arg : public mpl::false_ {}; 00258 00259 template<class T> 00260 struct is_out_arg<AStore<T&> > : public mpl::true_ 00261 {}; 00262 00263 template<class T> 00264 struct is_out_arg<AStore<T const &> > : public mpl::false_ 00265 {}; 00266 00267 template<int, class T> 00268 struct BindStorageImpl; 00269 00274 template<class ToBind> 00275 struct BindStorageImpl<0, ToBind> 00276 { 00277 typedef typename boost::function_traits<ToBind>::result_type result_type; 00278 typedef RStore<result_type> RStoreType; 00279 00280 boost::function<ToBind> mmeth; 00281 00282 mutable RStore<result_type> retv; 00283 #ifdef ORO_SIGNALLING_OPERATIONS 00284 typename Signal<ToBind>::shared_ptr msig; 00285 #endif 00286 // stores the original function pointer 00287 00288 // the list of all our storage. 00289 bf::vector< RStore<result_type>&> vStore; 00290 BindStorageImpl() : vStore(boost::ref(retv)) {} 00291 BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv) {} 00292 00293 void exec() { 00294 #ifdef ORO_SIGNALLING_OPERATIONS 00295 if (msig) msig->emit(); 00296 #endif 00297 if (mmeth) 00298 retv.exec( mmeth ); 00299 else 00300 retv.executed = true; 00301 } 00302 }; 00303 00307 template<class ToBind> 00308 struct BindStorageImpl<1, ToBind> 00309 { 00310 typedef typename boost::function_traits<ToBind>::result_type result_type; 00311 typedef typename boost::function_traits<ToBind>::arg1_type arg1_type; 00312 typedef RStore<result_type> RStoreType; 00313 00314 // stores the original function pointer, supplied by the user. 00315 boost::function<ToBind> mmeth; 00316 // Store the argument. 00317 mutable AStore<arg1_type> a1; 00318 mutable RStore<result_type> retv; 00319 #ifdef ORO_SIGNALLING_OPERATIONS 00320 typename Signal<ToBind>::shared_ptr msig; 00321 #endif 00322 00323 // the list of all our storage. 00324 bf::vector< RStore<result_type>&, AStore<arg1_type>& > vStore; 00325 BindStorageImpl() : vStore(retv,a1) {} 00326 BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1) {} 00327 void store(arg1_type t1) { a1(t1); } 00328 void exec() { 00329 #ifdef ORO_SIGNALLING_OPERATIONS 00330 if (msig) (*msig)(a1.get()); 00331 #endif 00332 if (mmeth) 00333 retv.exec( boost::bind(mmeth, boost::ref(a1.get()) ) ); 00334 else 00335 retv.executed = true; 00336 } 00337 00338 }; 00339 00340 template<class ToBind> 00341 struct BindStorageImpl<2, ToBind> 00342 { 00343 typedef typename boost::function_traits<ToBind>::result_type result_type; 00344 typedef typename boost::function_traits<ToBind>::arg1_type arg1_type; 00345 typedef typename boost::function_traits<ToBind>::arg2_type arg2_type; 00346 typedef RStore<result_type> RStoreType; 00347 00348 // stores the original function pointer 00349 boost::function<ToBind> mmeth; 00350 // Store the arguments. 00351 mutable AStore<arg1_type> a1; 00352 mutable AStore<arg2_type> a2; 00353 mutable RStore<result_type> retv; 00354 #ifdef ORO_SIGNALLING_OPERATIONS 00355 typename Signal<ToBind>::shared_ptr msig; 00356 #endif 00357 00358 // the list of all our storage. 00359 bf::vector< RStore<result_type>&, AStore<arg1_type>&, AStore<arg2_type>& > vStore; 00360 BindStorageImpl() : vStore(retv,a1,a2) {} 00361 BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2) {} 00362 00363 void store(arg1_type t1, arg2_type t2) { a1(t1); a2(t2); } 00364 void exec() { 00365 #ifdef ORO_SIGNALLING_OPERATIONS 00366 if (msig) (*msig)(a1.get(), a2.get()); 00367 #endif 00368 if (mmeth) 00369 retv.exec( boost::bind(mmeth, boost::ref(a1.get()), boost::ref(a2.get()) ) ); 00370 else 00371 retv.executed = true; 00372 } 00373 00374 }; 00375 00376 template<class ToBind> 00377 struct BindStorageImpl<3, ToBind> 00378 { 00379 typedef typename boost::function_traits<ToBind>::result_type result_type; 00380 typedef typename boost::function_traits<ToBind>::arg1_type arg1_type; 00381 typedef typename boost::function_traits<ToBind>::arg2_type arg2_type; 00382 typedef typename boost::function_traits<ToBind>::arg3_type arg3_type; 00383 typedef RStore<result_type> RStoreType; 00384 00385 // stores the original function pointer 00386 boost::function<ToBind> mmeth; 00387 // Store the arguments. 00388 mutable AStore<arg1_type> a1; 00389 mutable AStore<arg2_type> a2; 00390 mutable AStore<arg3_type> a3; 00391 mutable RStore<result_type> retv; 00392 #ifdef ORO_SIGNALLING_OPERATIONS 00393 typename Signal<ToBind>::shared_ptr msig; 00394 #endif 00395 00396 // the list of all our storage. 00397 bf::vector< RStore<result_type>&, AStore<arg1_type>&, AStore<arg2_type>&, AStore<arg3_type>& > vStore; 00398 BindStorageImpl() : vStore(retv,a1,a2,a3) {} 00399 BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2,a3) {} 00400 00401 void store(arg1_type t1, arg2_type t2, arg3_type t3) { a1(t1); a2(t2); a3(t3); } 00402 void exec() { 00403 #ifdef ORO_SIGNALLING_OPERATIONS 00404 if (msig) (*msig)(a1.get(), a2.get(), a3.get()); 00405 #endif 00406 if (mmeth) 00407 retv.exec( boost::bind(mmeth, boost::ref(a1.get()), boost::ref(a2.get()), boost::ref(a3.get()) ) ); 00408 else 00409 retv.executed = true; 00410 } 00411 }; 00412 00413 template<class ToBind> 00414 struct BindStorageImpl<4, ToBind> 00415 { 00416 typedef typename boost::function_traits<ToBind>::result_type result_type; 00417 typedef typename boost::function_traits<ToBind>::arg1_type arg1_type; 00418 typedef typename boost::function_traits<ToBind>::arg2_type arg2_type; 00419 typedef typename boost::function_traits<ToBind>::arg3_type arg3_type; 00420 typedef typename boost::function_traits<ToBind>::arg4_type arg4_type; 00421 typedef RStore<result_type> RStoreType; 00422 00423 // stores the original function pointer 00424 boost::function<ToBind> mmeth; 00425 // Store the arguments. 00426 mutable AStore<arg1_type> a1; 00427 mutable AStore<arg2_type> a2; 00428 mutable AStore<arg3_type> a3; 00429 mutable AStore<arg4_type> a4; 00430 mutable RStore<result_type> retv; 00431 #ifdef ORO_SIGNALLING_OPERATIONS 00432 typename Signal<ToBind>::shared_ptr msig; 00433 #endif 00434 00435 // the list of all our storage. 00436 bf::vector< RStore<result_type>&, AStore<arg1_type>&, AStore<arg2_type>&, AStore<arg3_type>&, AStore<arg4_type>& > vStore; 00437 BindStorageImpl() : vStore(retv,a1,a2,a3,a4) {} 00438 BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2,a3,a4) {} 00439 00440 void store(arg1_type t1, arg2_type t2, arg3_type t3, arg4_type t4) { a1(t1); a2(t2); a3(t3); a4(t4); } 00441 void exec() { 00442 #ifdef ORO_SIGNALLING_OPERATIONS 00443 if (msig) (*msig)(a1.get(), a2.get(), a3.get(), a4.get()); 00444 #endif 00445 if (mmeth) 00446 retv.exec( boost::bind( mmeth, boost::ref(a1.get()), boost::ref(a2.get()), boost::ref(a3.get()), boost::ref(a4.get()) ) ); 00447 else 00448 retv.executed = true; 00449 } 00450 }; 00451 00452 template<class ToBind> 00453 struct BindStorageImpl<5, ToBind> 00454 { 00455 typedef typename boost::function_traits<ToBind>::result_type result_type; 00456 typedef typename boost::function_traits<ToBind>::arg1_type arg1_type; 00457 typedef typename boost::function_traits<ToBind>::arg2_type arg2_type; 00458 typedef typename boost::function_traits<ToBind>::arg3_type arg3_type; 00459 typedef typename boost::function_traits<ToBind>::arg4_type arg4_type; 00460 typedef typename boost::function_traits<ToBind>::arg5_type arg5_type; 00461 typedef RStore<result_type> RStoreType; 00462 00463 // stores the original function pointer 00464 boost::function<ToBind> mmeth; 00465 // Store the arguments. 00466 mutable AStore<arg1_type> a1; 00467 mutable AStore<arg2_type> a2; 00468 mutable AStore<arg3_type> a3; 00469 mutable AStore<arg4_type> a4; 00470 mutable AStore<arg5_type> a5; 00471 mutable RStore<result_type> retv; 00472 #ifdef ORO_SIGNALLING_OPERATIONS 00473 typename Signal<ToBind>::shared_ptr msig; 00474 #endif 00475 00476 // the list of all our storage. 00477 bf::vector< RStore<result_type>&, AStore<arg1_type>&, AStore<arg2_type>&, AStore<arg3_type>&, AStore<arg4_type>&, AStore<arg5_type>& > vStore; 00478 BindStorageImpl() : vStore(retv,a1,a2,a3,a4,a5) {} 00479 BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2,a3,a4,a5) {} 00480 00481 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);} 00482 void exec() { 00483 #ifdef ORO_SIGNALLING_OPERATIONS 00484 if (msig) (*msig)(a1.get(), a2.get(), a3.get(), a4.get(), a5.get()); 00485 #endif 00486 if (mmeth) 00487 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()) ) ); 00488 else 00489 retv.executed = true; 00490 } 00491 }; 00492 00493 template<class ToBind> 00494 struct BindStorageImpl<6, ToBind> 00495 { 00496 typedef typename boost::function_traits<ToBind>::result_type result_type; 00497 typedef typename boost::function_traits<ToBind>::arg1_type arg1_type; 00498 typedef typename boost::function_traits<ToBind>::arg2_type arg2_type; 00499 typedef typename boost::function_traits<ToBind>::arg3_type arg3_type; 00500 typedef typename boost::function_traits<ToBind>::arg4_type arg4_type; 00501 typedef typename boost::function_traits<ToBind>::arg5_type arg5_type; 00502 typedef typename boost::function_traits<ToBind>::arg6_type arg6_type; 00503 typedef RStore<result_type> RStoreType; 00504 00505 // stores the original function pointer 00506 boost::function<ToBind> mmeth; 00507 // Store the arguments. 00508 mutable AStore<arg1_type> a1; 00509 mutable AStore<arg2_type> a2; 00510 mutable AStore<arg3_type> a3; 00511 mutable AStore<arg4_type> a4; 00512 mutable AStore<arg5_type> a5; 00513 mutable AStore<arg6_type> a6; 00514 mutable RStore<result_type> retv; 00515 #ifdef ORO_SIGNALLING_OPERATIONS 00516 typename Signal<ToBind>::shared_ptr msig; 00517 #endif 00518 00519 // the list of all our storage. 00520 bf::vector< RStore<result_type>&, AStore<arg1_type>&, AStore<arg2_type>&, AStore<arg3_type>&, AStore<arg4_type>&, AStore<arg5_type>&, AStore<arg6_type>& > vStore; 00521 BindStorageImpl() : vStore(retv,a1,a2,a3,a4,a5,a6) {} 00522 BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2,a3,a4,a5,a6) {} 00523 00524 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);} 00525 void exec() { 00526 #ifdef ORO_SIGNALLING_OPERATIONS 00527 if (msig) (*msig)(a1.get(), a2.get(), a3.get(), a4.get(), a5.get(), a6.get()); 00528 #endif 00529 if (mmeth) 00530 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()) ) ); 00531 else 00532 retv.executed = true; 00533 } 00534 }; 00535 00536 template<class ToBind> 00537 struct BindStorageImpl<7, ToBind> 00538 { 00539 typedef typename boost::function_traits<ToBind>::result_type result_type; 00540 typedef typename boost::function_traits<ToBind>::arg1_type arg1_type; 00541 typedef typename boost::function_traits<ToBind>::arg2_type arg2_type; 00542 typedef typename boost::function_traits<ToBind>::arg3_type arg3_type; 00543 typedef typename boost::function_traits<ToBind>::arg4_type arg4_type; 00544 typedef typename boost::function_traits<ToBind>::arg5_type arg5_type; 00545 typedef typename boost::function_traits<ToBind>::arg6_type arg6_type; 00546 typedef typename boost::function_traits<ToBind>::arg7_type arg7_type; 00547 typedef RStore<result_type> RStoreType; 00548 00549 // stores the original function pointer 00550 boost::function<ToBind> mmeth; 00551 // Store the arguments. 00552 mutable AStore<arg1_type> a1; 00553 mutable AStore<arg2_type> a2; 00554 mutable AStore<arg3_type> a3; 00555 mutable AStore<arg4_type> a4; 00556 mutable AStore<arg5_type> a5; 00557 mutable AStore<arg6_type> a6; 00558 mutable AStore<arg7_type> a7; 00559 mutable RStore<result_type> retv; 00560 #ifdef ORO_SIGNALLING_OPERATIONS 00561 typename Signal<ToBind>::shared_ptr msig; 00562 #endif 00563 00564 // the list of all our storage. 00565 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; 00566 BindStorageImpl() : vStore(retv,a1,a2,a3,a4,a5,a6,a7) {} 00567 BindStorageImpl(const BindStorageImpl& orig) : mmeth(orig.mmeth), vStore(retv,a1,a2,a3,a4,a5,a6,a7) {} 00568 00569 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);} 00570 void exec() { 00571 #ifdef ORO_SIGNALLING_OPERATIONS 00572 if (msig) (*msig)(a1.get(), a2.get(), a3.get(), a4.get(), a5.get(), a6.get(), a7.get()); 00573 #endif 00574 if (mmeth) 00575 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()) ) ); 00576 else 00577 retv.executed = true; 00578 } 00579 }; 00580 00581 00600 template<class ToBind> 00601 struct BindStorage 00602 : public BindStorageImpl<boost::function_traits<ToBind>::arity, ToBind> 00603 { 00604 }; 00605 } 00606 } 00607 #endif
1.7.6.1