00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <dbus-cxx/forward_decls.h>
00024 #include <dbus-cxx/methodproxybase.h>
00025 #include <dbus-cxx/utility.h>
00026
00027 #ifndef DBUSCXX_METHODPROXY_H
00028 #define DBUSCXX_METHODPROXY_H
00029
00030 namespace DBus {
00031
00032
00039 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
00040 class MethodProxy
00041 : public MethodProxyBase
00042 {
00043 public:
00044
00045 typedef DBusCxxPointer<MethodProxy> pointer;
00046
00047 MethodProxy(const std::string& name):
00048 MethodProxyBase(name)
00049 { }
00050
00051 T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5,T_arg6 _val_6,T_arg7 _val_7)
00052 {
00053 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::operator() method=" << m_name );
00054 CallMessage::pointer _callmsg = this->create_call_message();
00055 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6 << _val_7;
00056 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00057 T_return _retval;
00058 retmsg >> _retval;
00059 return _retval;
00060 }
00061
00062 static pointer create(const std::string& name)
00063 { return pointer( new MethodProxy(name) ); }
00064
00065 };
00066
00067
00068
00075 template <class T_return>
00076 class MethodProxy <T_return, nil,nil,nil,nil,nil,nil,nil>
00077 : public MethodProxyBase
00078 {
00079 public:
00080
00081 typedef DBusCxxPointer<MethodProxy> pointer;
00082
00083 MethodProxy(const std::string& name):
00084 MethodProxyBase(name)
00085 { }
00086
00087 T_return operator()()
00088 {
00089 DBUS_CXX_DEBUG("Method<T_return>::operator() method=" << m_name );
00090 CallMessage::pointer _callmsg = this->create_call_message();
00091
00092 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00093 T_return _retval;
00094 retmsg >> _retval;
00095 return _retval;
00096 }
00097
00098 static pointer create(const std::string& name)
00099 { return pointer( new MethodProxy(name) ); }
00100
00101 };
00102
00103
00110 template <class T_return, class T_arg1>
00111 class MethodProxy <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00112 : public MethodProxyBase
00113 {
00114 public:
00115
00116 typedef DBusCxxPointer<MethodProxy> pointer;
00117
00118 MethodProxy(const std::string& name):
00119 MethodProxyBase(name)
00120 { }
00121
00122 T_return operator()(T_arg1 _val_1)
00123 {
00124 DBUS_CXX_DEBUG("Method<T_return, T_arg1>::operator() method=" << m_name );
00125 CallMessage::pointer _callmsg = this->create_call_message();
00126 *_callmsg << _val_1;
00127 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00128 T_return _retval;
00129 retmsg >> _retval;
00130 return _retval;
00131 }
00132
00133 static pointer create(const std::string& name)
00134 { return pointer( new MethodProxy(name) ); }
00135
00136 };
00137
00138
00145 template <class T_return, class T_arg1,class T_arg2>
00146 class MethodProxy <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00147 : public MethodProxyBase
00148 {
00149 public:
00150
00151 typedef DBusCxxPointer<MethodProxy> pointer;
00152
00153 MethodProxy(const std::string& name):
00154 MethodProxyBase(name)
00155 { }
00156
00157 T_return operator()(T_arg1 _val_1,T_arg2 _val_2)
00158 {
00159 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::operator() method=" << m_name );
00160 CallMessage::pointer _callmsg = this->create_call_message();
00161 *_callmsg << _val_1 << _val_2;
00162 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00163 T_return _retval;
00164 retmsg >> _retval;
00165 return _retval;
00166 }
00167
00168 static pointer create(const std::string& name)
00169 { return pointer( new MethodProxy(name) ); }
00170
00171 };
00172
00173
00180 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00181 class MethodProxy <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00182 : public MethodProxyBase
00183 {
00184 public:
00185
00186 typedef DBusCxxPointer<MethodProxy> pointer;
00187
00188 MethodProxy(const std::string& name):
00189 MethodProxyBase(name)
00190 { }
00191
00192 T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3)
00193 {
00194 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::operator() method=" << m_name );
00195 CallMessage::pointer _callmsg = this->create_call_message();
00196 *_callmsg << _val_1 << _val_2 << _val_3;
00197 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00198 T_return _retval;
00199 retmsg >> _retval;
00200 return _retval;
00201 }
00202
00203 static pointer create(const std::string& name)
00204 { return pointer( new MethodProxy(name) ); }
00205
00206 };
00207
00208
00215 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00216 class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00217 : public MethodProxyBase
00218 {
00219 public:
00220
00221 typedef DBusCxxPointer<MethodProxy> pointer;
00222
00223 MethodProxy(const std::string& name):
00224 MethodProxyBase(name)
00225 { }
00226
00227 T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4)
00228 {
00229 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::operator() method=" << m_name );
00230 CallMessage::pointer _callmsg = this->create_call_message();
00231 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4;
00232 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00233 T_return _retval;
00234 retmsg >> _retval;
00235 return _retval;
00236 }
00237
00238 static pointer create(const std::string& name)
00239 { return pointer( new MethodProxy(name) ); }
00240
00241 };
00242
00243
00250 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00251 class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00252 : public MethodProxyBase
00253 {
00254 public:
00255
00256 typedef DBusCxxPointer<MethodProxy> pointer;
00257
00258 MethodProxy(const std::string& name):
00259 MethodProxyBase(name)
00260 { }
00261
00262 T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5)
00263 {
00264 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::operator() method=" << m_name );
00265 CallMessage::pointer _callmsg = this->create_call_message();
00266 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4 << _val_5;
00267 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00268 T_return _retval;
00269 retmsg >> _retval;
00270 return _retval;
00271 }
00272
00273 static pointer create(const std::string& name)
00274 { return pointer( new MethodProxy(name) ); }
00275
00276 };
00277
00278
00285 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00286 class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00287 : public MethodProxyBase
00288 {
00289 public:
00290
00291 typedef DBusCxxPointer<MethodProxy> pointer;
00292
00293 MethodProxy(const std::string& name):
00294 MethodProxyBase(name)
00295 { }
00296
00297 T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5,T_arg6 _val_6)
00298 {
00299 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::operator() method=" << m_name );
00300 CallMessage::pointer _callmsg = this->create_call_message();
00301 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6;
00302 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00303 T_return _retval;
00304 retmsg >> _retval;
00305 return _retval;
00306 }
00307
00308 static pointer create(const std::string& name)
00309 { return pointer( new MethodProxy(name) ); }
00310
00311 };
00312
00313
00316 template <>
00317 class MethodProxy <void, nil,nil,nil,nil,nil,nil,nil>
00318 : public MethodProxyBase
00319 {
00320 public:
00321
00322 typedef DBusCxxPointer<MethodProxy> pointer;
00323
00324 MethodProxy(const std::string& name):
00325 MethodProxyBase(name)
00326 { }
00327
00328 void operator()()
00329 {
00330 DBUS_CXX_DEBUG("Method<T_return>::operator() method=" << m_name );
00331 CallMessage::pointer _callmsg = this->create_call_message();
00332 *_callmsg ;
00333 _callmsg->set_no_reply();
00334 this->call( _callmsg );
00335 }
00336
00337 static pointer create(const std::string& name)
00338 { return pointer( new MethodProxy(name) ); }
00339
00340 };
00341
00344 template <class T_arg1>
00345 class MethodProxy <void, T_arg1, nil,nil,nil,nil,nil,nil>
00346 : public MethodProxyBase
00347 {
00348 public:
00349
00350 typedef DBusCxxPointer<MethodProxy> pointer;
00351
00352 MethodProxy(const std::string& name):
00353 MethodProxyBase(name)
00354 { }
00355
00356 void operator()(T_arg1 _val_1)
00357 {
00358 DBUS_CXX_DEBUG("Method<T_return, T_arg1>::operator() method=" << m_name );
00359 CallMessage::pointer _callmsg = this->create_call_message();
00360 *_callmsg << _val_1;
00361 _callmsg->set_no_reply();
00362 this->call( _callmsg );
00363 }
00364
00365 static pointer create(const std::string& name)
00366 { return pointer( new MethodProxy(name) ); }
00367
00368 };
00369
00372 template <class T_arg1,class T_arg2>
00373 class MethodProxy <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00374 : public MethodProxyBase
00375 {
00376 public:
00377
00378 typedef DBusCxxPointer<MethodProxy> pointer;
00379
00380 MethodProxy(const std::string& name):
00381 MethodProxyBase(name)
00382 { }
00383
00384 void operator()(T_arg1 _val_1,T_arg2 _val_2)
00385 {
00386 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::operator() method=" << m_name );
00387 CallMessage::pointer _callmsg = this->create_call_message();
00388 *_callmsg << _val_1 << _val_2;
00389 _callmsg->set_no_reply();
00390 this->call( _callmsg );
00391 }
00392
00393 static pointer create(const std::string& name)
00394 { return pointer( new MethodProxy(name) ); }
00395
00396 };
00397
00400 template <class T_arg1,class T_arg2,class T_arg3>
00401 class MethodProxy <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00402 : public MethodProxyBase
00403 {
00404 public:
00405
00406 typedef DBusCxxPointer<MethodProxy> pointer;
00407
00408 MethodProxy(const std::string& name):
00409 MethodProxyBase(name)
00410 { }
00411
00412 void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3)
00413 {
00414 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::operator() method=" << m_name );
00415 CallMessage::pointer _callmsg = this->create_call_message();
00416 *_callmsg << _val_1 << _val_2 << _val_3;
00417 _callmsg->set_no_reply();
00418 this->call( _callmsg );
00419 }
00420
00421 static pointer create(const std::string& name)
00422 { return pointer( new MethodProxy(name) ); }
00423
00424 };
00425
00428 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00429 class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00430 : public MethodProxyBase
00431 {
00432 public:
00433
00434 typedef DBusCxxPointer<MethodProxy> pointer;
00435
00436 MethodProxy(const std::string& name):
00437 MethodProxyBase(name)
00438 { }
00439
00440 void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4)
00441 {
00442 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::operator() method=" << m_name );
00443 CallMessage::pointer _callmsg = this->create_call_message();
00444 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4;
00445 _callmsg->set_no_reply();
00446 this->call( _callmsg );
00447 }
00448
00449 static pointer create(const std::string& name)
00450 { return pointer( new MethodProxy(name) ); }
00451
00452 };
00453
00456 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00457 class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00458 : public MethodProxyBase
00459 {
00460 public:
00461
00462 typedef DBusCxxPointer<MethodProxy> pointer;
00463
00464 MethodProxy(const std::string& name):
00465 MethodProxyBase(name)
00466 { }
00467
00468 void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5)
00469 {
00470 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::operator() method=" << m_name );
00471 CallMessage::pointer _callmsg = this->create_call_message();
00472 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4 << _val_5;
00473 _callmsg->set_no_reply();
00474 this->call( _callmsg );
00475 }
00476
00477 static pointer create(const std::string& name)
00478 { return pointer( new MethodProxy(name) ); }
00479
00480 };
00481
00484 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00485 class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00486 : public MethodProxyBase
00487 {
00488 public:
00489
00490 typedef DBusCxxPointer<MethodProxy> pointer;
00491
00492 MethodProxy(const std::string& name):
00493 MethodProxyBase(name)
00494 { }
00495
00496 void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5,T_arg6 _val_6)
00497 {
00498 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::operator() method=" << m_name );
00499 CallMessage::pointer _callmsg = this->create_call_message();
00500 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6;
00501 _callmsg->set_no_reply();
00502 this->call( _callmsg );
00503 }
00504
00505 static pointer create(const std::string& name)
00506 { return pointer( new MethodProxy(name) ); }
00507
00508 };
00509
00510
00511
00512 }
00513
00514 #endif