00001
00002
00003
00004
00005 #ifndef DBUS_CXX_METHOD_IMPL_H
00006 #define DBUS_CXX_METHOD_IMPL_H
00007
00008 #include <dbus-cxx/method.h>
00009 #include <dbus-cxx/connection.h>
00010
00011 namespace DBus {
00012
00015 template <>
00016 class Method <void, nil,nil,nil,nil,nil,nil,nil>
00017 : public MethodBase
00018 {
00019 public:
00020
00021 typedef DBusCxxPointer<Method> pointer;
00022
00023 Method(const std::string& name):
00024 MethodBase(name)
00025 { }
00026
00027 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00028 {
00029 DBUS_CXX_DEBUG("Method<void>::handle_call_message method=" << m_name );
00030
00031 if ( not connection or not message ) return NOT_HANDLED;
00032
00033
00034
00035
00036
00037 m_slot();
00038
00039 ReturnMessage::const_pointer retmsg;
00040
00041 if ( message->expects_reply() )
00042 {
00043 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00044 retmsg = message->create_reply();
00045 if ( not retmsg ) return NOT_HANDLED;
00046 connection << retmsg;
00047 }
00048
00049 return HANDLED;
00050 }
00051
00052 void set_method( sigc::slot0<void> slot )
00053 { m_slot = slot; }
00054
00055 static pointer create(const std::string& name)
00056 { return pointer( new Method(name) ); }
00057
00058 virtual MethodBase::pointer clone()
00059 { return MethodBase::pointer( new Method(this->name()) ); }
00060
00061 protected:
00062
00063 sigc::slot0<void> m_slot;
00064
00065 };
00066
00069 template <class T_arg1>
00070 class Method <void, T_arg1, nil,nil,nil,nil,nil,nil>
00071 : public MethodBase
00072 {
00073 public:
00074
00075 typedef DBusCxxPointer<Method> pointer;
00076
00077 Method(const std::string& name):
00078 MethodBase(name)
00079 { }
00080
00081 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00082 {
00083 DBUS_CXX_DEBUG("Method<void, T_arg1>::handle_call_message method=" << m_name );
00084
00085 if ( not connection or not message ) return NOT_HANDLED;
00086
00087
00088 T_arg1 _val_1;
00089
00090
00091 try {
00092 Message::iterator i = message->begin();
00093 i >> _val_1;
00094 }
00095 catch ( ErrorInvalidTypecast& e ) {
00096 return NOT_HANDLED;
00097 }
00098
00099
00100 m_slot(_val_1);
00101
00102 ReturnMessage::const_pointer retmsg;
00103
00104 if ( message->expects_reply() )
00105 {
00106 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00107 retmsg = message->create_reply();
00108 if ( not retmsg ) return NOT_HANDLED;
00109 connection << retmsg;
00110 }
00111
00112 return HANDLED;
00113 }
00114
00115 void set_method( sigc::slot1<void, T_arg1> slot )
00116 { m_slot = slot; }
00117
00118 static pointer create(const std::string& name)
00119 { return pointer( new Method(name) ); }
00120
00121 virtual MethodBase::pointer clone()
00122 { return MethodBase::pointer( new Method(this->name()) ); }
00123
00124 protected:
00125
00126 sigc::slot1<void, T_arg1> m_slot;
00127
00128 };
00129
00132 template <class T_arg1,class T_arg2>
00133 class Method <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00134 : public MethodBase
00135 {
00136 public:
00137
00138 typedef DBusCxxPointer<Method> pointer;
00139
00140 Method(const std::string& name):
00141 MethodBase(name)
00142 { }
00143
00144 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00145 {
00146 DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2>::handle_call_message method=" << m_name );
00147
00148 if ( not connection or not message ) return NOT_HANDLED;
00149
00150
00151 T_arg1 _val_1;
00152 T_arg2 _val_2;
00153
00154
00155 try {
00156 Message::iterator i = message->begin();
00157 i >> _val_1 >> _val_2;
00158 }
00159 catch ( ErrorInvalidTypecast& e ) {
00160 return NOT_HANDLED;
00161 }
00162
00163
00164 m_slot(_val_1,_val_2);
00165
00166 ReturnMessage::const_pointer retmsg;
00167
00168 if ( message->expects_reply() )
00169 {
00170 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00171 retmsg = message->create_reply();
00172 if ( not retmsg ) return NOT_HANDLED;
00173 connection << retmsg;
00174 }
00175
00176 return HANDLED;
00177 }
00178
00179 void set_method( sigc::slot2<void, T_arg1,T_arg2> slot )
00180 { m_slot = slot; }
00181
00182 static pointer create(const std::string& name)
00183 { return pointer( new Method(name) ); }
00184
00185 virtual MethodBase::pointer clone()
00186 { return MethodBase::pointer( new Method(this->name()) ); }
00187
00188 protected:
00189
00190 sigc::slot2<void, T_arg1,T_arg2> m_slot;
00191
00192 };
00193
00196 template <class T_arg1,class T_arg2,class T_arg3>
00197 class Method <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00198 : public MethodBase
00199 {
00200 public:
00201
00202 typedef DBusCxxPointer<Method> pointer;
00203
00204 Method(const std::string& name):
00205 MethodBase(name)
00206 { }
00207
00208 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00209 {
00210 DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3>::handle_call_message method=" << m_name );
00211
00212 if ( not connection or not message ) return NOT_HANDLED;
00213
00214
00215 T_arg1 _val_1;
00216 T_arg2 _val_2;
00217 T_arg3 _val_3;
00218
00219
00220 try {
00221 Message::iterator i = message->begin();
00222 i >> _val_1 >> _val_2 >> _val_3;
00223 }
00224 catch ( ErrorInvalidTypecast& e ) {
00225 return NOT_HANDLED;
00226 }
00227
00228
00229 m_slot(_val_1,_val_2,_val_3);
00230
00231 ReturnMessage::const_pointer retmsg;
00232
00233 if ( message->expects_reply() )
00234 {
00235 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00236 retmsg = message->create_reply();
00237 if ( not retmsg ) return NOT_HANDLED;
00238 connection << retmsg;
00239 }
00240
00241 return HANDLED;
00242 }
00243
00244 void set_method( sigc::slot3<void, T_arg1,T_arg2,T_arg3> slot )
00245 { m_slot = slot; }
00246
00247 static pointer create(const std::string& name)
00248 { return pointer( new Method(name) ); }
00249
00250 virtual MethodBase::pointer clone()
00251 { return MethodBase::pointer( new Method(this->name()) ); }
00252
00253 protected:
00254
00255 sigc::slot3<void, T_arg1,T_arg2,T_arg3> m_slot;
00256
00257 };
00258
00261 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00262 class Method <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00263 : public MethodBase
00264 {
00265 public:
00266
00267 typedef DBusCxxPointer<Method> pointer;
00268
00269 Method(const std::string& name):
00270 MethodBase(name)
00271 { }
00272
00273 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00274 {
00275 DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message method=" << m_name );
00276
00277 if ( not connection or not message ) return NOT_HANDLED;
00278
00279
00280 T_arg1 _val_1;
00281 T_arg2 _val_2;
00282 T_arg3 _val_3;
00283 T_arg4 _val_4;
00284
00285
00286 try {
00287 Message::iterator i = message->begin();
00288 i >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00289 }
00290 catch ( ErrorInvalidTypecast& e ) {
00291 return NOT_HANDLED;
00292 }
00293
00294
00295 m_slot(_val_1,_val_2,_val_3,_val_4);
00296
00297 ReturnMessage::const_pointer retmsg;
00298
00299 if ( message->expects_reply() )
00300 {
00301 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00302 retmsg = message->create_reply();
00303 if ( not retmsg ) return NOT_HANDLED;
00304 connection << retmsg;
00305 }
00306
00307 return HANDLED;
00308 }
00309
00310 void set_method( sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00311 { m_slot = slot; }
00312
00313 static pointer create(const std::string& name)
00314 { return pointer( new Method(name) ); }
00315
00316 virtual MethodBase::pointer clone()
00317 { return MethodBase::pointer( new Method(this->name()) ); }
00318
00319 protected:
00320
00321 sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
00322
00323 };
00324
00327 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00328 class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00329 : public MethodBase
00330 {
00331 public:
00332
00333 typedef DBusCxxPointer<Method> pointer;
00334
00335 Method(const std::string& name):
00336 MethodBase(name)
00337 { }
00338
00339 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00340 {
00341 DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message method=" << m_name );
00342
00343 if ( not connection or not message ) return NOT_HANDLED;
00344
00345
00346 T_arg1 _val_1;
00347 T_arg2 _val_2;
00348 T_arg3 _val_3;
00349 T_arg4 _val_4;
00350 T_arg5 _val_5;
00351
00352
00353 try {
00354 Message::iterator i = message->begin();
00355 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
00356 }
00357 catch ( ErrorInvalidTypecast& e ) {
00358 return NOT_HANDLED;
00359 }
00360
00361
00362 m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
00363
00364 ReturnMessage::const_pointer retmsg;
00365
00366 if ( message->expects_reply() )
00367 {
00368 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00369 retmsg = message->create_reply();
00370 if ( not retmsg ) return NOT_HANDLED;
00371 connection << retmsg;
00372 }
00373
00374 return HANDLED;
00375 }
00376
00377 void set_method( sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
00378 { m_slot = slot; }
00379
00380 static pointer create(const std::string& name)
00381 { return pointer( new Method(name) ); }
00382
00383 virtual MethodBase::pointer clone()
00384 { return MethodBase::pointer( new Method(this->name()) ); }
00385
00386 protected:
00387
00388 sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
00389
00390 };
00391
00394 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00395 class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00396 : public MethodBase
00397 {
00398 public:
00399
00400 typedef DBusCxxPointer<Method> pointer;
00401
00402 Method(const std::string& name):
00403 MethodBase(name)
00404 { }
00405
00406 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00407 {
00408 DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message method=" << m_name );
00409
00410 if ( not connection or not message ) return NOT_HANDLED;
00411
00412
00413 T_arg1 _val_1;
00414 T_arg2 _val_2;
00415 T_arg3 _val_3;
00416 T_arg4 _val_4;
00417 T_arg5 _val_5;
00418 T_arg6 _val_6;
00419
00420
00421 try {
00422 Message::iterator i = message->begin();
00423 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
00424 }
00425 catch ( ErrorInvalidTypecast& e ) {
00426 return NOT_HANDLED;
00427 }
00428
00429
00430 m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
00431
00432 ReturnMessage::const_pointer retmsg;
00433
00434 if ( message->expects_reply() )
00435 {
00436 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00437 retmsg = message->create_reply();
00438 if ( not retmsg ) return NOT_HANDLED;
00439 connection << retmsg;
00440 }
00441
00442 return HANDLED;
00443 }
00444
00445 void set_method( sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
00446 { m_slot = slot; }
00447
00448 static pointer create(const std::string& name)
00449 { return pointer( new Method(name) ); }
00450
00451 virtual MethodBase::pointer clone()
00452 { return MethodBase::pointer( new Method(this->name()) ); }
00453
00454 protected:
00455
00456 sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
00457
00458 };
00459
00460
00461
00462 }
00463
00464 #endif