00001
00002
00003
00004
00005 #ifndef DBUS_CXX_METHOD_H
00006 #define DBUS_CXX_METHOD_H
00007
00008 #include <dbus-cxx/methodbase.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 Method
00021 : public MethodBase
00022 {
00023 public:
00024
00025 typedef DBusCxxPointer<Method> pointer;
00026
00027 Method(const std::string& name):
00028 MethodBase(name)
00029 { }
00030
00031 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00032 {
00033 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::handle_call_message method=" << m_name );
00034
00035 if ( not connection or not message ) return NOT_HANDLED;
00036
00037 T_return _retval;
00038
00039 T_arg1 _val_1;
00040 T_arg2 _val_2;
00041 T_arg3 _val_3;
00042 T_arg4 _val_4;
00043 T_arg5 _val_5;
00044 T_arg6 _val_6;
00045 T_arg7 _val_7;
00046
00047
00048 try {
00049 Message::iterator i = message->begin();
00050 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
00051 }
00052 catch ( ErrorInvalidTypecast& e ) {
00053 return NOT_HANDLED;
00054 }
00055
00056
00057 _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
00058
00059 ReturnMessage::pointer retmsg = message->create_reply();
00060
00061 if ( not retmsg ) return NOT_HANDLED;
00062
00063 retmsg << _retval;
00064
00065 connection << retmsg;
00066
00067 return HANDLED;
00068 }
00069
00070 void set_method( sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot )
00071 { m_slot = slot; }
00072
00073 static pointer create(const std::string& name)
00074 { return pointer( new Method(name) ); }
00075
00076 virtual MethodBase::pointer clone()
00077 { return MethodBase::pointer( new Method(this->name()) ); }
00078
00079 protected:
00080
00081 sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> m_slot;
00082
00083 };
00084
00085
00086
00093 template <class T_return>
00094 class Method <T_return, nil,nil,nil,nil,nil,nil,nil>
00095 : public MethodBase
00096 {
00097 public:
00098
00099 typedef DBusCxxPointer<Method> pointer;
00100
00101 Method(const std::string& name):
00102 MethodBase(name)
00103 { }
00104
00105 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00106 {
00107 DBUS_CXX_DEBUG("Method<T_return>::handle_call_message method=" << m_name );
00108
00109 if ( not connection or not message ) return NOT_HANDLED;
00110
00111 T_return _retval;
00112
00113
00114
00115
00116 _retval = m_slot();
00117
00118 ReturnMessage::pointer retmsg = message->create_reply();
00119
00120 if ( not retmsg ) return NOT_HANDLED;
00121
00122 retmsg << _retval;
00123
00124 connection << retmsg;
00125
00126 return HANDLED;
00127 }
00128
00129 void set_method( sigc::slot0<T_return> slot )
00130 { m_slot = slot; }
00131
00132 static pointer create(const std::string& name)
00133 { return pointer( new Method(name) ); }
00134
00135 virtual MethodBase::pointer clone()
00136 { return MethodBase::pointer( new Method(this->name()) ); }
00137
00138 protected:
00139
00140 sigc::slot0<T_return> m_slot;
00141
00142 };
00143
00144
00151 template <class T_return, class T_arg1>
00152 class Method <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00153 : public MethodBase
00154 {
00155 public:
00156
00157 typedef DBusCxxPointer<Method> pointer;
00158
00159 Method(const std::string& name):
00160 MethodBase(name)
00161 { }
00162
00163 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00164 {
00165 DBUS_CXX_DEBUG("Method<T_return, T_arg1>::handle_call_message method=" << m_name );
00166
00167 if ( not connection or not message ) return NOT_HANDLED;
00168
00169 T_return _retval;
00170
00171 T_arg1 _val_1;
00172
00173
00174 try {
00175 Message::iterator i = message->begin();
00176 i >> _val_1;
00177 }
00178 catch ( ErrorInvalidTypecast& e ) {
00179 return NOT_HANDLED;
00180 }
00181
00182
00183 _retval = m_slot(_val_1);
00184
00185 ReturnMessage::pointer retmsg = message->create_reply();
00186
00187 if ( not retmsg ) return NOT_HANDLED;
00188
00189 retmsg << _retval;
00190
00191 connection << retmsg;
00192
00193 return HANDLED;
00194 }
00195
00196 void set_method( sigc::slot1<T_return, T_arg1> slot )
00197 { m_slot = slot; }
00198
00199 static pointer create(const std::string& name)
00200 { return pointer( new Method(name) ); }
00201
00202 virtual MethodBase::pointer clone()
00203 { return MethodBase::pointer( new Method(this->name()) ); }
00204
00205 protected:
00206
00207 sigc::slot1<T_return, T_arg1> m_slot;
00208
00209 };
00210
00211
00218 template <class T_return, class T_arg1,class T_arg2>
00219 class Method <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00220 : public MethodBase
00221 {
00222 public:
00223
00224 typedef DBusCxxPointer<Method> pointer;
00225
00226 Method(const std::string& name):
00227 MethodBase(name)
00228 { }
00229
00230 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00231 {
00232 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::handle_call_message method=" << m_name );
00233
00234 if ( not connection or not message ) return NOT_HANDLED;
00235
00236 T_return _retval;
00237
00238 T_arg1 _val_1;
00239 T_arg2 _val_2;
00240
00241
00242 try {
00243 Message::iterator i = message->begin();
00244 i >> _val_1 >> _val_2;
00245 }
00246 catch ( ErrorInvalidTypecast& e ) {
00247 return NOT_HANDLED;
00248 }
00249
00250
00251 _retval = m_slot(_val_1,_val_2);
00252
00253 ReturnMessage::pointer retmsg = message->create_reply();
00254
00255 if ( not retmsg ) return NOT_HANDLED;
00256
00257 retmsg << _retval;
00258
00259 connection << retmsg;
00260
00261 return HANDLED;
00262 }
00263
00264 void set_method( sigc::slot2<T_return, T_arg1,T_arg2> slot )
00265 { m_slot = slot; }
00266
00267 static pointer create(const std::string& name)
00268 { return pointer( new Method(name) ); }
00269
00270 virtual MethodBase::pointer clone()
00271 { return MethodBase::pointer( new Method(this->name()) ); }
00272
00273 protected:
00274
00275 sigc::slot2<T_return, T_arg1,T_arg2> m_slot;
00276
00277 };
00278
00279
00286 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00287 class Method <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00288 : public MethodBase
00289 {
00290 public:
00291
00292 typedef DBusCxxPointer<Method> pointer;
00293
00294 Method(const std::string& name):
00295 MethodBase(name)
00296 { }
00297
00298 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00299 {
00300 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::handle_call_message method=" << m_name );
00301
00302 if ( not connection or not message ) return NOT_HANDLED;
00303
00304 T_return _retval;
00305
00306 T_arg1 _val_1;
00307 T_arg2 _val_2;
00308 T_arg3 _val_3;
00309
00310
00311 try {
00312 Message::iterator i = message->begin();
00313 i >> _val_1 >> _val_2 >> _val_3;
00314 }
00315 catch ( ErrorInvalidTypecast& e ) {
00316 return NOT_HANDLED;
00317 }
00318
00319
00320 _retval = m_slot(_val_1,_val_2,_val_3);
00321
00322 ReturnMessage::pointer retmsg = message->create_reply();
00323
00324 if ( not retmsg ) return NOT_HANDLED;
00325
00326 retmsg << _retval;
00327
00328 connection << retmsg;
00329
00330 return HANDLED;
00331 }
00332
00333 void set_method( sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> slot )
00334 { m_slot = slot; }
00335
00336 static pointer create(const std::string& name)
00337 { return pointer( new Method(name) ); }
00338
00339 virtual MethodBase::pointer clone()
00340 { return MethodBase::pointer( new Method(this->name()) ); }
00341
00342 protected:
00343
00344 sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> m_slot;
00345
00346 };
00347
00348
00355 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00356 class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00357 : public MethodBase
00358 {
00359 public:
00360
00361 typedef DBusCxxPointer<Method> pointer;
00362
00363 Method(const std::string& name):
00364 MethodBase(name)
00365 { }
00366
00367 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00368 {
00369 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message method=" << m_name );
00370
00371 if ( not connection or not message ) return NOT_HANDLED;
00372
00373 T_return _retval;
00374
00375 T_arg1 _val_1;
00376 T_arg2 _val_2;
00377 T_arg3 _val_3;
00378 T_arg4 _val_4;
00379
00380
00381 try {
00382 Message::iterator i = message->begin();
00383 i >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00384 }
00385 catch ( ErrorInvalidTypecast& e ) {
00386 return NOT_HANDLED;
00387 }
00388
00389
00390 _retval = m_slot(_val_1,_val_2,_val_3,_val_4);
00391
00392 ReturnMessage::pointer retmsg = message->create_reply();
00393
00394 if ( not retmsg ) return NOT_HANDLED;
00395
00396 retmsg << _retval;
00397
00398 connection << retmsg;
00399
00400 return HANDLED;
00401 }
00402
00403 void set_method( sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00404 { m_slot = slot; }
00405
00406 static pointer create(const std::string& name)
00407 { return pointer( new Method(name) ); }
00408
00409 virtual MethodBase::pointer clone()
00410 { return MethodBase::pointer( new Method(this->name()) ); }
00411
00412 protected:
00413
00414 sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
00415
00416 };
00417
00418
00425 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00426 class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00427 : public MethodBase
00428 {
00429 public:
00430
00431 typedef DBusCxxPointer<Method> pointer;
00432
00433 Method(const std::string& name):
00434 MethodBase(name)
00435 { }
00436
00437 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00438 {
00439 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message method=" << m_name );
00440
00441 if ( not connection or not message ) return NOT_HANDLED;
00442
00443 T_return _retval;
00444
00445 T_arg1 _val_1;
00446 T_arg2 _val_2;
00447 T_arg3 _val_3;
00448 T_arg4 _val_4;
00449 T_arg5 _val_5;
00450
00451
00452 try {
00453 Message::iterator i = message->begin();
00454 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
00455 }
00456 catch ( ErrorInvalidTypecast& e ) {
00457 return NOT_HANDLED;
00458 }
00459
00460
00461 _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
00462
00463 ReturnMessage::pointer retmsg = message->create_reply();
00464
00465 if ( not retmsg ) return NOT_HANDLED;
00466
00467 retmsg << _retval;
00468
00469 connection << retmsg;
00470
00471 return HANDLED;
00472 }
00473
00474 void set_method( sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
00475 { m_slot = slot; }
00476
00477 static pointer create(const std::string& name)
00478 { return pointer( new Method(name) ); }
00479
00480 virtual MethodBase::pointer clone()
00481 { return MethodBase::pointer( new Method(this->name()) ); }
00482
00483 protected:
00484
00485 sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
00486
00487 };
00488
00489
00496 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00497 class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00498 : public MethodBase
00499 {
00500 public:
00501
00502 typedef DBusCxxPointer<Method> pointer;
00503
00504 Method(const std::string& name):
00505 MethodBase(name)
00506 { }
00507
00508 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00509 {
00510 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message method=" << m_name );
00511
00512 if ( not connection or not message ) return NOT_HANDLED;
00513
00514 T_return _retval;
00515
00516 T_arg1 _val_1;
00517 T_arg2 _val_2;
00518 T_arg3 _val_3;
00519 T_arg4 _val_4;
00520 T_arg5 _val_5;
00521 T_arg6 _val_6;
00522
00523
00524 try {
00525 Message::iterator i = message->begin();
00526 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
00527 }
00528 catch ( ErrorInvalidTypecast& e ) {
00529 return NOT_HANDLED;
00530 }
00531
00532
00533 _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
00534
00535 ReturnMessage::pointer retmsg = message->create_reply();
00536
00537 if ( not retmsg ) return NOT_HANDLED;
00538
00539 retmsg << _retval;
00540
00541 connection << retmsg;
00542
00543 return HANDLED;
00544 }
00545
00546 void set_method( sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
00547 { m_slot = slot; }
00548
00549 static pointer create(const std::string& name)
00550 { return pointer( new Method(name) ); }
00551
00552 virtual MethodBase::pointer clone()
00553 { return MethodBase::pointer( new Method(this->name()) ); }
00554
00555 protected:
00556
00557 sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
00558
00559 };
00560
00561
00562
00563 }
00564
00565 #endif
00566