00001
00002
00003
00004
00005 #ifndef DBUSCXXMETHODPROXY_H
00006 #define DBUSCXXMETHODPROXY_H
00007
00008 #include <dbus-cxx/methodproxybase.h>
00009
00010 namespace DBus {
00011
00012
00019 template <class T_return, class T_arg1 = nil,class T_arg2 = nil,class T_arg3 = nil,class T_arg4 = nil,class T_arg5 = nil,class T_arg6 = nil,class T_arg7 = nil>
00020 class MethodProxy
00021 : public MethodProxyBase
00022 {
00023 public:
00024
00025 typedef DBusCxxPointer<MethodProxy> pointer;
00026
00027 MethodProxy(const std::string& name):
00028 MethodProxyBase(name)
00029 { }
00030
00031 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)
00032 {
00033 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::operator() method=" << m_name );
00034 CallMessage::pointer _callmsg = this->create_call_message();
00035 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6 << _val_7;
00036 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00037 T_return _retval;
00038 retmsg >> _retval;
00039 return _retval;
00040 }
00041
00042 static pointer create(const std::string& name)
00043 { return pointer( new MethodProxy(name) ); }
00044
00045 };
00046
00047
00048
00055 template <class T_return>
00056 class MethodProxy <T_return, nil,nil,nil,nil,nil,nil,nil>
00057 : public MethodProxyBase
00058 {
00059 public:
00060
00061 typedef DBusCxxPointer<MethodProxy> pointer;
00062
00063 MethodProxy(const std::string& name):
00064 MethodProxyBase(name)
00065 { }
00066
00067 T_return operator()()
00068 {
00069 DBUS_CXX_DEBUG("Method<T_return>::operator() method=" << m_name );
00070 CallMessage::pointer _callmsg = this->create_call_message();
00071
00072 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00073 T_return _retval;
00074 retmsg >> _retval;
00075 return _retval;
00076 }
00077
00078 static pointer create(const std::string& name)
00079 { return pointer( new MethodProxy(name) ); }
00080
00081 };
00082
00083
00090 template <class T_return, class T_arg1>
00091 class MethodProxy <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00092 : public MethodProxyBase
00093 {
00094 public:
00095
00096 typedef DBusCxxPointer<MethodProxy> pointer;
00097
00098 MethodProxy(const std::string& name):
00099 MethodProxyBase(name)
00100 { }
00101
00102 T_return operator()(T_arg1 _val_1)
00103 {
00104 DBUS_CXX_DEBUG("Method<T_return, T_arg1>::operator() method=" << m_name );
00105 CallMessage::pointer _callmsg = this->create_call_message();
00106 *_callmsg << _val_1;
00107 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00108 T_return _retval;
00109 retmsg >> _retval;
00110 return _retval;
00111 }
00112
00113 static pointer create(const std::string& name)
00114 { return pointer( new MethodProxy(name) ); }
00115
00116 };
00117
00118
00125 template <class T_return, class T_arg1,class T_arg2>
00126 class MethodProxy <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00127 : public MethodProxyBase
00128 {
00129 public:
00130
00131 typedef DBusCxxPointer<MethodProxy> pointer;
00132
00133 MethodProxy(const std::string& name):
00134 MethodProxyBase(name)
00135 { }
00136
00137 T_return operator()(T_arg1 _val_1,T_arg2 _val_2)
00138 {
00139 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::operator() method=" << m_name );
00140 CallMessage::pointer _callmsg = this->create_call_message();
00141 *_callmsg << _val_1 << _val_2;
00142 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00143 T_return _retval;
00144 retmsg >> _retval;
00145 return _retval;
00146 }
00147
00148 static pointer create(const std::string& name)
00149 { return pointer( new MethodProxy(name) ); }
00150
00151 };
00152
00153
00160 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00161 class MethodProxy <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00162 : public MethodProxyBase
00163 {
00164 public:
00165
00166 typedef DBusCxxPointer<MethodProxy> pointer;
00167
00168 MethodProxy(const std::string& name):
00169 MethodProxyBase(name)
00170 { }
00171
00172 T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3)
00173 {
00174 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::operator() method=" << m_name );
00175 CallMessage::pointer _callmsg = this->create_call_message();
00176 *_callmsg << _val_1 << _val_2 << _val_3;
00177 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00178 T_return _retval;
00179 retmsg >> _retval;
00180 return _retval;
00181 }
00182
00183 static pointer create(const std::string& name)
00184 { return pointer( new MethodProxy(name) ); }
00185
00186 };
00187
00188
00195 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00196 class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00197 : public MethodProxyBase
00198 {
00199 public:
00200
00201 typedef DBusCxxPointer<MethodProxy> pointer;
00202
00203 MethodProxy(const std::string& name):
00204 MethodProxyBase(name)
00205 { }
00206
00207 T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4)
00208 {
00209 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::operator() method=" << m_name );
00210 CallMessage::pointer _callmsg = this->create_call_message();
00211 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4;
00212 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00213 T_return _retval;
00214 retmsg >> _retval;
00215 return _retval;
00216 }
00217
00218 static pointer create(const std::string& name)
00219 { return pointer( new MethodProxy(name) ); }
00220
00221 };
00222
00223
00230 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00231 class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00232 : public MethodProxyBase
00233 {
00234 public:
00235
00236 typedef DBusCxxPointer<MethodProxy> pointer;
00237
00238 MethodProxy(const std::string& name):
00239 MethodProxyBase(name)
00240 { }
00241
00242 T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5)
00243 {
00244 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::operator() method=" << m_name );
00245 CallMessage::pointer _callmsg = this->create_call_message();
00246 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4 << _val_5;
00247 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00248 T_return _retval;
00249 retmsg >> _retval;
00250 return _retval;
00251 }
00252
00253 static pointer create(const std::string& name)
00254 { return pointer( new MethodProxy(name) ); }
00255
00256 };
00257
00258
00265 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00266 class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00267 : public MethodProxyBase
00268 {
00269 public:
00270
00271 typedef DBusCxxPointer<MethodProxy> pointer;
00272
00273 MethodProxy(const std::string& name):
00274 MethodProxyBase(name)
00275 { }
00276
00277 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)
00278 {
00279 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::operator() method=" << m_name );
00280 CallMessage::pointer _callmsg = this->create_call_message();
00281 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6;
00282 ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00283 T_return _retval;
00284 retmsg >> _retval;
00285 return _retval;
00286 }
00287
00288 static pointer create(const std::string& name)
00289 { return pointer( new MethodProxy(name) ); }
00290
00291 };
00292
00293
00296 template <>
00297 class MethodProxy <void, nil,nil,nil,nil,nil,nil,nil>
00298 : public MethodProxyBase
00299 {
00300 public:
00301
00302 typedef DBusCxxPointer<MethodProxy> pointer;
00303
00304 MethodProxy(const std::string& name):
00305 MethodProxyBase(name)
00306 { }
00307
00308 void operator()()
00309 {
00310 DBUS_CXX_DEBUG("Method<T_return>::operator() method=" << m_name );
00311 CallMessage::pointer _callmsg = this->create_call_message();
00312 *_callmsg ;
00313 _callmsg->set_no_reply();
00314 this->call( _callmsg );
00315 }
00316
00317 static pointer create(const std::string& name)
00318 { return pointer( new MethodProxy(name) ); }
00319
00320 };
00321
00324 template <class T_arg1>
00325 class MethodProxy <void, T_arg1, nil,nil,nil,nil,nil,nil>
00326 : public MethodProxyBase
00327 {
00328 public:
00329
00330 typedef DBusCxxPointer<MethodProxy> pointer;
00331
00332 MethodProxy(const std::string& name):
00333 MethodProxyBase(name)
00334 { }
00335
00336 void operator()(T_arg1 _val_1)
00337 {
00338 DBUS_CXX_DEBUG("Method<T_return, T_arg1>::operator() method=" << m_name );
00339 CallMessage::pointer _callmsg = this->create_call_message();
00340 *_callmsg << _val_1;
00341 _callmsg->set_no_reply();
00342 this->call( _callmsg );
00343 }
00344
00345 static pointer create(const std::string& name)
00346 { return pointer( new MethodProxy(name) ); }
00347
00348 };
00349
00352 template <class T_arg1,class T_arg2>
00353 class MethodProxy <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00354 : public MethodProxyBase
00355 {
00356 public:
00357
00358 typedef DBusCxxPointer<MethodProxy> pointer;
00359
00360 MethodProxy(const std::string& name):
00361 MethodProxyBase(name)
00362 { }
00363
00364 void operator()(T_arg1 _val_1,T_arg2 _val_2)
00365 {
00366 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::operator() method=" << m_name );
00367 CallMessage::pointer _callmsg = this->create_call_message();
00368 *_callmsg << _val_1 << _val_2;
00369 _callmsg->set_no_reply();
00370 this->call( _callmsg );
00371 }
00372
00373 static pointer create(const std::string& name)
00374 { return pointer( new MethodProxy(name) ); }
00375
00376 };
00377
00380 template <class T_arg1,class T_arg2,class T_arg3>
00381 class MethodProxy <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00382 : public MethodProxyBase
00383 {
00384 public:
00385
00386 typedef DBusCxxPointer<MethodProxy> pointer;
00387
00388 MethodProxy(const std::string& name):
00389 MethodProxyBase(name)
00390 { }
00391
00392 void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3)
00393 {
00394 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::operator() method=" << m_name );
00395 CallMessage::pointer _callmsg = this->create_call_message();
00396 *_callmsg << _val_1 << _val_2 << _val_3;
00397 _callmsg->set_no_reply();
00398 this->call( _callmsg );
00399 }
00400
00401 static pointer create(const std::string& name)
00402 { return pointer( new MethodProxy(name) ); }
00403
00404 };
00405
00408 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00409 class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00410 : public MethodProxyBase
00411 {
00412 public:
00413
00414 typedef DBusCxxPointer<MethodProxy> pointer;
00415
00416 MethodProxy(const std::string& name):
00417 MethodProxyBase(name)
00418 { }
00419
00420 void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4)
00421 {
00422 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::operator() method=" << m_name );
00423 CallMessage::pointer _callmsg = this->create_call_message();
00424 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4;
00425 _callmsg->set_no_reply();
00426 this->call( _callmsg );
00427 }
00428
00429 static pointer create(const std::string& name)
00430 { return pointer( new MethodProxy(name) ); }
00431
00432 };
00433
00436 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00437 class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00438 : public MethodProxyBase
00439 {
00440 public:
00441
00442 typedef DBusCxxPointer<MethodProxy> pointer;
00443
00444 MethodProxy(const std::string& name):
00445 MethodProxyBase(name)
00446 { }
00447
00448 void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5)
00449 {
00450 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::operator() method=" << m_name );
00451 CallMessage::pointer _callmsg = this->create_call_message();
00452 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4 << _val_5;
00453 _callmsg->set_no_reply();
00454 this->call( _callmsg );
00455 }
00456
00457 static pointer create(const std::string& name)
00458 { return pointer( new MethodProxy(name) ); }
00459
00460 };
00461
00464 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00465 class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00466 : public MethodProxyBase
00467 {
00468 public:
00469
00470 typedef DBusCxxPointer<MethodProxy> pointer;
00471
00472 MethodProxy(const std::string& name):
00473 MethodProxyBase(name)
00474 { }
00475
00476 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)
00477 {
00478 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::operator() method=" << m_name );
00479 CallMessage::pointer _callmsg = this->create_call_message();
00480 *_callmsg << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6;
00481 _callmsg->set_no_reply();
00482 this->call( _callmsg );
00483 }
00484
00485 static pointer create(const std::string& name)
00486 { return pointer( new MethodProxy(name) ); }
00487
00488 };
00489
00490
00491
00492 }
00493
00494 #endif