|
Orocos Real-Time Toolkit
2.6.0
|
00001 /*************************************************************************** 00002 tag: FMTC do nov 2 13:06:13 CET 2006 DataSourceStorage.hpp 00003 00004 DataSourceStorage.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_DATASOURCE_STORAGE_HPP 00040 #define ORO_TASK_DATASOURCE_STORAGE_HPP 00041 00042 #include <boost/function.hpp> 00043 #include <boost/bind.hpp> 00044 #include <boost/mem_fn.hpp> 00045 #include <boost/function_types/function_type.hpp> 00046 #include <boost/function_types/function_arity.hpp> 00047 #include "DataSources.hpp" 00048 #include "BindStorage.hpp" 00049 00050 namespace RTT 00051 { 00052 namespace internal 00053 { 00060 template<class T> 00061 struct DSRStore { 00062 T arg; 00063 DSRStore() : arg() {} 00064 00065 T& result() { return arg; } 00066 operator T&() { return arg; } 00067 }; 00068 00069 template<class T> 00070 struct DSRStore<T&> 00071 { 00072 typedef typename boost::remove_const<T>::type result_type; 00073 result_type arg; 00074 DSRStore() : arg() {} 00075 result_type& result() { return arg; } // non const return 00076 operator result_type&() { return arg; } 00077 }; 00078 00079 template<> 00080 struct DSRStore<void> { 00081 DSRStore() {} 00082 void result() { return; } 00083 }; 00084 00085 template<> 00086 struct is_arg_return<DSRStore<void> > : public mpl::false_ 00087 {}; 00088 00089 template<class T> 00090 struct is_arg_return<DSRStore<T> > : public mpl::true_ 00091 {}; 00092 00093 00096 template<class R> 00097 struct DataSourceResultStorage 00098 { 00099 typedef typename remove_cr<R>::type ds_type; 00100 DSRStore<R> retn; 00101 typename ReferenceDataSource<ds_type>::shared_ptr result; 00102 00103 DataSourceResultStorage() 00104 : result( new ReferenceDataSource<ds_type>(retn.result()) ) 00105 { 00106 } 00107 00108 template<class ContainerT> 00109 void initRet(ContainerT& cc) { 00110 cc.ret(base::DataSourceBase::shared_ptr(result)); 00111 } 00112 00113 R getResult() { 00114 return retn.result(); 00115 } 00116 }; 00117 00118 template<> 00119 struct DataSourceResultStorage<void> 00120 { 00121 typedef void result_type; 00122 DSRStore<void> retn; 00123 DataSourceResultStorage() 00124 { 00125 } 00126 00127 template<class ContainerT> 00128 void initRet(ContainerT& ) {} 00129 00130 void getResult() {} 00131 }; 00132 00135 template<class R> 00136 struct DataSourceResultStorage<R const&> 00137 { 00138 typedef R const& result_type; 00139 typedef R ds_type; 00140 DSRStore<result_type> retn; 00141 typename ReferenceDataSource<ds_type>::shared_ptr result; 00142 00143 DataSourceResultStorage() 00144 : result( new ReferenceDataSource<ds_type>( retn.result() ) ) 00145 { 00146 } 00147 00148 template<class ContainerT> 00149 void initRet(ContainerT& cc) { 00150 cc.ret(base::DataSourceBase::shared_ptr(result)); 00151 } 00152 00153 result_type getResult() { 00154 return result->rvalue(); 00155 } 00156 }; 00157 00164 template<class A> 00165 struct DataSourceArgStorage 00166 { 00167 typedef typename remove_cr<A>::type ds_type; 00168 typedef AStore<A&> Store; 00169 typename ValueDataSource<ds_type>::shared_ptr value; 00170 AStore<A&> arg; 00171 DataSourceArgStorage() 00172 : value( new ValueDataSource<ds_type>() ) 00173 {} 00174 // We store the copy of 'a' in the data source, such that 00175 // that copy is always valid memory (refcounted). If we 00176 // would store it in 'arg' and use a LateReferenceDataSource, 00177 // we would loose/corrupt the data if this object is destroyed. 00178 // This is acceptable for ref/constref cases, but not for 00179 // value cases, which are often living on the stack and by 00180 // definition short lived. 00181 void newarg(A a) { arg( value->set() ); value->set(a); } 00182 }; 00183 00185 template<class A> 00186 struct DataSourceArgStorage<A &> 00187 { 00188 typedef AStore<A&> Store; 00189 AStore<A&> arg; 00190 typedef typename remove_cr<A>::type ds_type; 00191 typename LateReferenceDataSource<ds_type>::shared_ptr value; 00192 DataSourceArgStorage() 00193 : value( new LateReferenceDataSource<ds_type>() ) 00194 {} 00195 void newarg(A& a) { arg(a); value->setPointer(&arg.get()); } 00196 }; 00197 00199 template<class A> 00200 struct DataSourceArgStorage<A const&> 00201 { 00202 typedef AStore<A const&> Store; 00203 AStore<A const&> arg; 00204 // without const&: 00205 typename LateConstReferenceDataSource<A>::shared_ptr value; 00206 DataSourceArgStorage() 00207 : value( new LateConstReferenceDataSource<A>() ) 00208 {} 00209 void newarg(A const& a) { arg(a); value->setPointer(&arg.get());} 00210 }; 00211 00212 template<int, class T> 00213 struct DataSourceStorageImpl; 00214 00218 template<class DataType> 00219 struct DataSourceStorageImpl<0, DataType> 00220 : public DataSourceResultStorage<typename boost::function_traits<DataType>::result_type> 00221 { 00222 typedef typename boost::function_traits<DataType>::result_type result_type; 00223 DataSourceStorageImpl() {} 00224 DataSourceStorageImpl(const DataSourceStorageImpl& orig) {} 00225 template<class ContainerT> 00226 void initArgs(ContainerT& ) {} 00227 }; 00228 00232 template<class DataType> 00233 struct DataSourceStorageImpl<1, DataType> 00234 : public DataSourceResultStorage<typename boost::function_traits<DataType>::result_type> 00235 { 00236 typedef typename boost::function_traits<DataType>::result_type result_type; 00237 typedef typename boost::function_traits<DataType>::arg1_type arg1_type; 00238 DataSourceArgStorage<arg1_type> ma1; 00239 typedef typename DataSourceArgStorage<arg1_type>::Store AStore1; 00240 00241 DataSourceStorageImpl() {} 00242 DataSourceStorageImpl(const DataSourceStorageImpl& orig) {} 00243 00244 template<class ContainerT> 00245 void initArgs(ContainerT& cc) { 00246 cc.arg( base::DataSourceBase::shared_ptr(ma1.value.get()) ); 00247 } 00248 00249 void store(arg1_type a1) { 00250 ma1.newarg(a1); 00251 } 00252 }; 00253 00254 template<class DataType> 00255 struct DataSourceStorageImpl<2, DataType> 00256 : public DataSourceResultStorage<typename boost::function_traits<DataType>::result_type> 00257 { 00258 typedef typename boost::function_traits<DataType>::result_type result_type; 00259 typedef typename boost::function_traits<DataType>::arg1_type arg1_type; 00260 typedef typename boost::function_traits<DataType>::arg2_type arg2_type; 00261 DataSourceArgStorage<arg1_type> ma1; 00262 DataSourceArgStorage<arg2_type> ma2; 00263 typedef typename DataSourceArgStorage<arg1_type>::Store AStore1; 00264 typedef typename DataSourceArgStorage<arg2_type>::Store AStore2; 00265 00266 DataSourceStorageImpl() {} 00267 DataSourceStorageImpl(const DataSourceStorageImpl& orig) {} 00268 00269 template<class ContainerT> 00270 void initArgs(ContainerT& cc) { 00271 cc.arg( base::DataSourceBase::shared_ptr(ma1.value) ); 00272 cc.arg( base::DataSourceBase::shared_ptr(ma2.value) ); 00273 } 00274 void store(arg1_type a1, arg2_type a2) { 00275 ma1.newarg(a1); 00276 ma2.newarg(a2); 00277 } 00278 }; 00279 00280 template<class DataType> 00281 struct DataSourceStorageImpl<3, DataType> 00282 : public DataSourceResultStorage<typename boost::function_traits<DataType>::result_type> 00283 { 00284 typedef typename boost::function_traits<DataType>::result_type result_type; 00285 typedef typename boost::function_traits<DataType>::arg1_type arg1_type; 00286 typedef typename boost::function_traits<DataType>::arg2_type arg2_type; 00287 typedef typename boost::function_traits<DataType>::arg3_type arg3_type; 00288 DataSourceArgStorage<arg1_type> ma1; 00289 DataSourceArgStorage<arg2_type> ma2; 00290 DataSourceArgStorage<arg3_type> ma3; 00291 typedef typename DataSourceArgStorage<arg1_type>::Store AStore1; 00292 typedef typename DataSourceArgStorage<arg2_type>::Store AStore2; 00293 typedef typename DataSourceArgStorage<arg3_type>::Store AStore3; 00294 00295 DataSourceStorageImpl() {} 00296 DataSourceStorageImpl(const DataSourceStorageImpl& orig) {} 00297 00298 template<class ContainerT> 00299 void initArgs(ContainerT& cc) { 00300 cc.arg( base::DataSourceBase::shared_ptr(ma1.value) ); 00301 cc.arg( base::DataSourceBase::shared_ptr(ma2.value) ); 00302 cc.arg( base::DataSourceBase::shared_ptr(ma3.value) ); 00303 } 00304 void store(arg1_type a1, arg2_type a2, arg3_type a3) { 00305 ma1.newarg(a1); 00306 ma2.newarg(a2); 00307 ma3.newarg(a3); 00308 } 00309 }; 00310 00311 template<class DataType> 00312 struct DataSourceStorageImpl<4, DataType> 00313 : public DataSourceResultStorage<typename boost::function_traits<DataType>::result_type> 00314 { 00315 typedef typename boost::function_traits<DataType>::result_type result_type; 00316 typedef typename boost::function_traits<DataType>::arg1_type arg1_type; 00317 typedef typename boost::function_traits<DataType>::arg2_type arg2_type; 00318 typedef typename boost::function_traits<DataType>::arg3_type arg3_type; 00319 typedef typename boost::function_traits<DataType>::arg4_type arg4_type; 00320 DataSourceArgStorage<arg1_type> ma1; 00321 DataSourceArgStorage<arg2_type> ma2; 00322 DataSourceArgStorage<arg3_type> ma3; 00323 DataSourceArgStorage<arg4_type> ma4; 00324 typedef typename DataSourceArgStorage<arg1_type>::Store AStore1; 00325 typedef typename DataSourceArgStorage<arg2_type>::Store AStore2; 00326 typedef typename DataSourceArgStorage<arg3_type>::Store AStore3; 00327 typedef typename DataSourceArgStorage<arg4_type>::Store AStore4; 00328 00329 DataSourceStorageImpl() {} 00330 DataSourceStorageImpl(const DataSourceStorageImpl& orig) {} 00331 00332 template<class ContainerT> 00333 void initArgs(ContainerT& cc) { 00334 cc.arg( base::DataSourceBase::shared_ptr(ma1.value) ); 00335 cc.arg( base::DataSourceBase::shared_ptr(ma2.value) ); 00336 cc.arg( base::DataSourceBase::shared_ptr(ma3.value) ); 00337 cc.arg( base::DataSourceBase::shared_ptr(ma4.value) ); 00338 } 00339 void store(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4) { 00340 ma1.newarg(a1); 00341 ma2.newarg(a2); 00342 ma3.newarg(a3); 00343 ma4.newarg(a4); 00344 } 00345 }; 00346 00347 template<class DataType> 00348 struct DataSourceStorageImpl<5, DataType> 00349 : public DataSourceResultStorage<typename boost::function_traits<DataType>::result_type> 00350 { 00351 typedef typename boost::function_traits<DataType>::result_type result_type; 00352 typedef typename boost::function_traits<DataType>::arg1_type arg1_type; 00353 typedef typename boost::function_traits<DataType>::arg2_type arg2_type; 00354 typedef typename boost::function_traits<DataType>::arg3_type arg3_type; 00355 typedef typename boost::function_traits<DataType>::arg4_type arg4_type; 00356 typedef typename boost::function_traits<DataType>::arg5_type arg5_type; 00357 DataSourceArgStorage<arg1_type> ma1; 00358 DataSourceArgStorage<arg2_type> ma2; 00359 DataSourceArgStorage<arg3_type> ma3; 00360 DataSourceArgStorage<arg4_type> ma4; 00361 DataSourceArgStorage<arg5_type> ma5; 00362 typedef typename DataSourceArgStorage<arg1_type>::Store AStore1; 00363 typedef typename DataSourceArgStorage<arg2_type>::Store AStore2; 00364 typedef typename DataSourceArgStorage<arg3_type>::Store AStore3; 00365 typedef typename DataSourceArgStorage<arg4_type>::Store AStore4; 00366 typedef typename DataSourceArgStorage<arg5_type>::Store AStore5; 00367 00368 DataSourceStorageImpl() {} 00369 DataSourceStorageImpl(const DataSourceStorageImpl& orig) {} 00370 00371 template<class ContainerT> 00372 void initArgs(ContainerT& cc) { 00373 cc.arg( base::DataSourceBase::shared_ptr(ma1.value) ); 00374 cc.arg( base::DataSourceBase::shared_ptr(ma2.value) ); 00375 cc.arg( base::DataSourceBase::shared_ptr(ma3.value) ); 00376 cc.arg( base::DataSourceBase::shared_ptr(ma4.value) ); 00377 cc.arg( base::DataSourceBase::shared_ptr(ma5.value) ); 00378 } 00379 void store(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5) { 00380 ma1.newarg(a1); 00381 ma2.newarg(a2); 00382 ma3.newarg(a3); 00383 ma4.newarg(a4); 00384 ma5.newarg(a5); 00385 } 00386 }; 00387 00388 template<class DataType> 00389 struct DataSourceStorageImpl<6, DataType> 00390 : public DataSourceResultStorage<typename boost::function_traits<DataType>::result_type> 00391 { 00392 typedef typename boost::function_traits<DataType>::result_type result_type; 00393 typedef typename boost::function_traits<DataType>::arg1_type arg1_type; 00394 typedef typename boost::function_traits<DataType>::arg2_type arg2_type; 00395 typedef typename boost::function_traits<DataType>::arg3_type arg3_type; 00396 typedef typename boost::function_traits<DataType>::arg4_type arg4_type; 00397 typedef typename boost::function_traits<DataType>::arg5_type arg5_type; 00398 typedef typename boost::function_traits<DataType>::arg6_type arg6_type; 00399 DataSourceArgStorage<arg1_type> ma1; 00400 DataSourceArgStorage<arg2_type> ma2; 00401 DataSourceArgStorage<arg3_type> ma3; 00402 DataSourceArgStorage<arg4_type> ma4; 00403 DataSourceArgStorage<arg5_type> ma5; 00404 DataSourceArgStorage<arg6_type> ma6; 00405 typedef typename DataSourceArgStorage<arg1_type>::Store AStore1; 00406 typedef typename DataSourceArgStorage<arg2_type>::Store AStore2; 00407 typedef typename DataSourceArgStorage<arg3_type>::Store AStore3; 00408 typedef typename DataSourceArgStorage<arg4_type>::Store AStore4; 00409 typedef typename DataSourceArgStorage<arg5_type>::Store AStore5; 00410 typedef typename DataSourceArgStorage<arg6_type>::Store AStore6; 00411 00412 DataSourceStorageImpl() {} 00413 DataSourceStorageImpl(const DataSourceStorageImpl& orig) {} 00414 00415 template<class ContainerT> 00416 void initArgs(ContainerT& cc) { 00417 cc.arg( base::DataSourceBase::shared_ptr(ma1.value) ); 00418 cc.arg( base::DataSourceBase::shared_ptr(ma2.value) ); 00419 cc.arg( base::DataSourceBase::shared_ptr(ma3.value) ); 00420 cc.arg( base::DataSourceBase::shared_ptr(ma4.value) ); 00421 cc.arg( base::DataSourceBase::shared_ptr(ma5.value) ); 00422 cc.arg( base::DataSourceBase::shared_ptr(ma6.value) ); 00423 } 00424 void store(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5, arg6_type a6) { 00425 ma1.newarg(a1); 00426 ma2.newarg(a2); 00427 ma3.newarg(a3); 00428 ma4.newarg(a4); 00429 ma5.newarg(a5); 00430 ma6.newarg(a6); 00431 } 00432 }; 00433 00434 template<class DataType> 00435 struct DataSourceStorageImpl<7, DataType> 00436 : public DataSourceResultStorage<typename boost::function_traits<DataType>::result_type> 00437 { 00438 typedef typename boost::function_traits<DataType>::result_type result_type; 00439 typedef typename boost::function_traits<DataType>::arg1_type arg1_type; 00440 typedef typename boost::function_traits<DataType>::arg2_type arg2_type; 00441 typedef typename boost::function_traits<DataType>::arg3_type arg3_type; 00442 typedef typename boost::function_traits<DataType>::arg4_type arg4_type; 00443 typedef typename boost::function_traits<DataType>::arg5_type arg5_type; 00444 typedef typename boost::function_traits<DataType>::arg6_type arg6_type; 00445 typedef typename boost::function_traits<DataType>::arg7_type arg7_type; 00446 DataSourceArgStorage<arg1_type> ma1; 00447 DataSourceArgStorage<arg2_type> ma2; 00448 DataSourceArgStorage<arg3_type> ma3; 00449 DataSourceArgStorage<arg4_type> ma4; 00450 DataSourceArgStorage<arg5_type> ma5; 00451 DataSourceArgStorage<arg6_type> ma6; 00452 DataSourceArgStorage<arg7_type> ma7; 00453 typedef typename DataSourceArgStorage<arg1_type>::Store AStore1; 00454 typedef typename DataSourceArgStorage<arg2_type>::Store AStore2; 00455 typedef typename DataSourceArgStorage<arg3_type>::Store AStore3; 00456 typedef typename DataSourceArgStorage<arg4_type>::Store AStore4; 00457 typedef typename DataSourceArgStorage<arg5_type>::Store AStore5; 00458 typedef typename DataSourceArgStorage<arg6_type>::Store AStore6; 00459 typedef typename DataSourceArgStorage<arg7_type>::Store AStore7; 00460 00461 DataSourceStorageImpl() {} 00462 DataSourceStorageImpl(const DataSourceStorageImpl& orig) {} 00463 00464 template<class ContainerT> 00465 void initArgs(ContainerT& cc) { 00466 cc.arg( base::DataSourceBase::shared_ptr(ma1.value) ); 00467 cc.arg( base::DataSourceBase::shared_ptr(ma2.value) ); 00468 cc.arg( base::DataSourceBase::shared_ptr(ma3.value) ); 00469 cc.arg( base::DataSourceBase::shared_ptr(ma4.value) ); 00470 cc.arg( base::DataSourceBase::shared_ptr(ma5.value) ); 00471 cc.arg( base::DataSourceBase::shared_ptr(ma6.value) ); 00472 cc.arg( base::DataSourceBase::shared_ptr(ma7.value) ); 00473 } 00474 void store(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4, arg5_type a5, arg6_type a6, arg7_type a7) { 00475 ma1.newarg(a1); 00476 ma2.newarg(a2); 00477 ma3.newarg(a3); 00478 ma4.newarg(a4); 00479 ma5.newarg(a5); 00480 ma6.newarg(a6); 00481 ma7.newarg(a7); 00482 } 00483 }; 00484 00491 template<class DataType> 00492 struct DataSourceStorage 00493 : public DataSourceStorageImpl<boost::function_traits<DataType>::arity, DataType> 00494 { 00495 }; 00496 } 00497 } 00498 #endif
1.7.6.1