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
00062 virtual std::string introspect(int space_depth=0) const
00063 {
00064 std::ostringstream sout;
00065 std::string spaces;
00066 for (int i=0; i < space_depth; i++ ) spaces += " ";
00067 sout << spaces << "<method name=\"" << name() << "\">\n";
00068
00069 sout << spaces << "</method>\n";
00070 return sout.str();
00071 }
00072
00073 virtual std::string arg_name(size_t i) {
00074 if ( i < 0+1 ) return m_arg_names[i];
00075 return std::string();
00076 }
00077
00078 virtual void set_arg_name(size_t i, const std::string& name) {
00079 if ( i < 0+1 ) m_arg_names[i] = name;
00080 }
00081
00082 protected:
00083
00084 std::string m_arg_names[0+1];
00085
00086 sigc::slot0<void> m_slot;
00087
00088 };
00089
00092 template <class T_arg1>
00093 class Method <void, T_arg1, nil,nil,nil,nil,nil,nil>
00094 : public MethodBase
00095 {
00096 public:
00097
00098 typedef DBusCxxPointer<Method> pointer;
00099
00100 Method(const std::string& name):
00101 MethodBase(name)
00102 { }
00103
00104 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00105 {
00106 DBUS_CXX_DEBUG("Method<void, T_arg1>::handle_call_message method=" << m_name );
00107
00108 if ( not connection or not message ) return NOT_HANDLED;
00109
00110
00111 T_arg1 _val_1;
00112
00113
00114 try {
00115 Message::iterator i = message->begin();
00116 i >> _val_1;
00117 }
00118 catch ( ErrorInvalidTypecast& e ) {
00119 return NOT_HANDLED;
00120 }
00121
00122
00123 m_slot(_val_1);
00124
00125 ReturnMessage::const_pointer retmsg;
00126
00127 if ( message->expects_reply() )
00128 {
00129 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00130 retmsg = message->create_reply();
00131 if ( not retmsg ) return NOT_HANDLED;
00132 connection << retmsg;
00133 }
00134
00135 return HANDLED;
00136 }
00137
00138 void set_method( sigc::slot1<void, T_arg1> slot )
00139 { m_slot = slot; }
00140
00141 static pointer create(const std::string& name)
00142 { return pointer( new Method(name) ); }
00143
00144 virtual MethodBase::pointer clone()
00145 { return MethodBase::pointer( new Method(this->name()) ); }
00146
00148 virtual std::string introspect(int space_depth=0) const
00149 {
00150 std::ostringstream sout;
00151 std::string spaces;
00152 for (int i=0; i < space_depth; i++ ) spaces += " ";
00153 sout << spaces << "<method name=\"" << name() << "\">\n";
00154
00155 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00156 sout << spaces << "</method>\n";
00157 return sout.str();
00158 }
00159
00160 virtual std::string arg_name(size_t i) {
00161 if ( i < 1+1 ) return m_arg_names[i];
00162 return std::string();
00163 }
00164
00165 virtual void set_arg_name(size_t i, const std::string& name) {
00166 if ( i < 1+1 ) m_arg_names[i] = name;
00167 }
00168
00169 protected:
00170
00171 std::string m_arg_names[1+1];
00172
00173 sigc::slot1<void, T_arg1> m_slot;
00174
00175 };
00176
00179 template <class T_arg1,class T_arg2>
00180 class Method <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00181 : public MethodBase
00182 {
00183 public:
00184
00185 typedef DBusCxxPointer<Method> pointer;
00186
00187 Method(const std::string& name):
00188 MethodBase(name)
00189 { }
00190
00191 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00192 {
00193 DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2>::handle_call_message method=" << m_name );
00194
00195 if ( not connection or not message ) return NOT_HANDLED;
00196
00197
00198 T_arg1 _val_1;
00199 T_arg2 _val_2;
00200
00201
00202 try {
00203 Message::iterator i = message->begin();
00204 i >> _val_1 >> _val_2;
00205 }
00206 catch ( ErrorInvalidTypecast& e ) {
00207 return NOT_HANDLED;
00208 }
00209
00210
00211 m_slot(_val_1,_val_2);
00212
00213 ReturnMessage::const_pointer retmsg;
00214
00215 if ( message->expects_reply() )
00216 {
00217 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00218 retmsg = message->create_reply();
00219 if ( not retmsg ) return NOT_HANDLED;
00220 connection << retmsg;
00221 }
00222
00223 return HANDLED;
00224 }
00225
00226 void set_method( sigc::slot2<void, T_arg1,T_arg2> slot )
00227 { m_slot = slot; }
00228
00229 static pointer create(const std::string& name)
00230 { return pointer( new Method(name) ); }
00231
00232 virtual MethodBase::pointer clone()
00233 { return MethodBase::pointer( new Method(this->name()) ); }
00234
00236 virtual std::string introspect(int space_depth=0) const
00237 {
00238 std::ostringstream sout;
00239 std::string spaces;
00240 for (int i=0; i < space_depth; i++ ) spaces += " ";
00241 sout << spaces << "<method name=\"" << name() << "\">\n";
00242
00243 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00244 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00245 sout << spaces << "</method>\n";
00246 return sout.str();
00247 }
00248
00249 virtual std::string arg_name(size_t i) {
00250 if ( i < 2+1 ) return m_arg_names[i];
00251 return std::string();
00252 }
00253
00254 virtual void set_arg_name(size_t i, const std::string& name) {
00255 if ( i < 2+1 ) m_arg_names[i] = name;
00256 }
00257
00258 protected:
00259
00260 std::string m_arg_names[2+1];
00261
00262 sigc::slot2<void, T_arg1,T_arg2> m_slot;
00263
00264 };
00265
00268 template <class T_arg1,class T_arg2,class T_arg3>
00269 class Method <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00270 : public MethodBase
00271 {
00272 public:
00273
00274 typedef DBusCxxPointer<Method> pointer;
00275
00276 Method(const std::string& name):
00277 MethodBase(name)
00278 { }
00279
00280 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00281 {
00282 DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3>::handle_call_message method=" << m_name );
00283
00284 if ( not connection or not message ) return NOT_HANDLED;
00285
00286
00287 T_arg1 _val_1;
00288 T_arg2 _val_2;
00289 T_arg3 _val_3;
00290
00291
00292 try {
00293 Message::iterator i = message->begin();
00294 i >> _val_1 >> _val_2 >> _val_3;
00295 }
00296 catch ( ErrorInvalidTypecast& e ) {
00297 return NOT_HANDLED;
00298 }
00299
00300
00301 m_slot(_val_1,_val_2,_val_3);
00302
00303 ReturnMessage::const_pointer retmsg;
00304
00305 if ( message->expects_reply() )
00306 {
00307 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00308 retmsg = message->create_reply();
00309 if ( not retmsg ) return NOT_HANDLED;
00310 connection << retmsg;
00311 }
00312
00313 return HANDLED;
00314 }
00315
00316 void set_method( sigc::slot3<void, T_arg1,T_arg2,T_arg3> slot )
00317 { m_slot = slot; }
00318
00319 static pointer create(const std::string& name)
00320 { return pointer( new Method(name) ); }
00321
00322 virtual MethodBase::pointer clone()
00323 { return MethodBase::pointer( new Method(this->name()) ); }
00324
00326 virtual std::string introspect(int space_depth=0) const
00327 {
00328 std::ostringstream sout;
00329 std::string spaces;
00330 for (int i=0; i < space_depth; i++ ) spaces += " ";
00331 sout << spaces << "<method name=\"" << name() << "\">\n";
00332
00333 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00334 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00335 sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00336 sout << spaces << "</method>\n";
00337 return sout.str();
00338 }
00339
00340 virtual std::string arg_name(size_t i) {
00341 if ( i < 3+1 ) return m_arg_names[i];
00342 return std::string();
00343 }
00344
00345 virtual void set_arg_name(size_t i, const std::string& name) {
00346 if ( i < 3+1 ) m_arg_names[i] = name;
00347 }
00348
00349 protected:
00350
00351 std::string m_arg_names[3+1];
00352
00353 sigc::slot3<void, T_arg1,T_arg2,T_arg3> m_slot;
00354
00355 };
00356
00359 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00360 class Method <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00361 : public MethodBase
00362 {
00363 public:
00364
00365 typedef DBusCxxPointer<Method> pointer;
00366
00367 Method(const std::string& name):
00368 MethodBase(name)
00369 { }
00370
00371 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00372 {
00373 DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message method=" << m_name );
00374
00375 if ( not connection or not message ) return NOT_HANDLED;
00376
00377
00378 T_arg1 _val_1;
00379 T_arg2 _val_2;
00380 T_arg3 _val_3;
00381 T_arg4 _val_4;
00382
00383
00384 try {
00385 Message::iterator i = message->begin();
00386 i >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00387 }
00388 catch ( ErrorInvalidTypecast& e ) {
00389 return NOT_HANDLED;
00390 }
00391
00392
00393 m_slot(_val_1,_val_2,_val_3,_val_4);
00394
00395 ReturnMessage::const_pointer retmsg;
00396
00397 if ( message->expects_reply() )
00398 {
00399 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00400 retmsg = message->create_reply();
00401 if ( not retmsg ) return NOT_HANDLED;
00402 connection << retmsg;
00403 }
00404
00405 return HANDLED;
00406 }
00407
00408 void set_method( sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00409 { m_slot = slot; }
00410
00411 static pointer create(const std::string& name)
00412 { return pointer( new Method(name) ); }
00413
00414 virtual MethodBase::pointer clone()
00415 { return MethodBase::pointer( new Method(this->name()) ); }
00416
00418 virtual std::string introspect(int space_depth=0) const
00419 {
00420 std::ostringstream sout;
00421 std::string spaces;
00422 for (int i=0; i < space_depth; i++ ) spaces += " ";
00423 sout << spaces << "<method name=\"" << name() << "\">\n";
00424
00425 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00426 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00427 sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00428 sout << spaces << " <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00429 sout << spaces << "</method>\n";
00430 return sout.str();
00431 }
00432
00433 virtual std::string arg_name(size_t i) {
00434 if ( i < 4+1 ) return m_arg_names[i];
00435 return std::string();
00436 }
00437
00438 virtual void set_arg_name(size_t i, const std::string& name) {
00439 if ( i < 4+1 ) m_arg_names[i] = name;
00440 }
00441
00442 protected:
00443
00444 std::string m_arg_names[4+1];
00445
00446 sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
00447
00448 };
00449
00452 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00453 class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00454 : public MethodBase
00455 {
00456 public:
00457
00458 typedef DBusCxxPointer<Method> pointer;
00459
00460 Method(const std::string& name):
00461 MethodBase(name)
00462 { }
00463
00464 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00465 {
00466 DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message method=" << m_name );
00467
00468 if ( not connection or not message ) return NOT_HANDLED;
00469
00470
00471 T_arg1 _val_1;
00472 T_arg2 _val_2;
00473 T_arg3 _val_3;
00474 T_arg4 _val_4;
00475 T_arg5 _val_5;
00476
00477
00478 try {
00479 Message::iterator i = message->begin();
00480 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
00481 }
00482 catch ( ErrorInvalidTypecast& e ) {
00483 return NOT_HANDLED;
00484 }
00485
00486
00487 m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
00488
00489 ReturnMessage::const_pointer retmsg;
00490
00491 if ( message->expects_reply() )
00492 {
00493 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00494 retmsg = message->create_reply();
00495 if ( not retmsg ) return NOT_HANDLED;
00496 connection << retmsg;
00497 }
00498
00499 return HANDLED;
00500 }
00501
00502 void set_method( sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
00503 { m_slot = slot; }
00504
00505 static pointer create(const std::string& name)
00506 { return pointer( new Method(name) ); }
00507
00508 virtual MethodBase::pointer clone()
00509 { return MethodBase::pointer( new Method(this->name()) ); }
00510
00512 virtual std::string introspect(int space_depth=0) const
00513 {
00514 std::ostringstream sout;
00515 std::string spaces;
00516 for (int i=0; i < space_depth; i++ ) spaces += " ";
00517 sout << spaces << "<method name=\"" << name() << "\">\n";
00518
00519 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00520 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00521 sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00522 sout << spaces << " <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00523 sout << spaces << " <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
00524 sout << spaces << "</method>\n";
00525 return sout.str();
00526 }
00527
00528 virtual std::string arg_name(size_t i) {
00529 if ( i < 5+1 ) return m_arg_names[i];
00530 return std::string();
00531 }
00532
00533 virtual void set_arg_name(size_t i, const std::string& name) {
00534 if ( i < 5+1 ) m_arg_names[i] = name;
00535 }
00536
00537 protected:
00538
00539 std::string m_arg_names[5+1];
00540
00541 sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
00542
00543 };
00544
00547 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00548 class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00549 : public MethodBase
00550 {
00551 public:
00552
00553 typedef DBusCxxPointer<Method> pointer;
00554
00555 Method(const std::string& name):
00556 MethodBase(name)
00557 { }
00558
00559 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00560 {
00561 DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message method=" << m_name );
00562
00563 if ( not connection or not message ) return NOT_HANDLED;
00564
00565
00566 T_arg1 _val_1;
00567 T_arg2 _val_2;
00568 T_arg3 _val_3;
00569 T_arg4 _val_4;
00570 T_arg5 _val_5;
00571 T_arg6 _val_6;
00572
00573
00574 try {
00575 Message::iterator i = message->begin();
00576 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
00577 }
00578 catch ( ErrorInvalidTypecast& e ) {
00579 return NOT_HANDLED;
00580 }
00581
00582
00583 m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
00584
00585 ReturnMessage::const_pointer retmsg;
00586
00587 if ( message->expects_reply() )
00588 {
00589 DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00590 retmsg = message->create_reply();
00591 if ( not retmsg ) return NOT_HANDLED;
00592 connection << retmsg;
00593 }
00594
00595 return HANDLED;
00596 }
00597
00598 void set_method( sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
00599 { m_slot = slot; }
00600
00601 static pointer create(const std::string& name)
00602 { return pointer( new Method(name) ); }
00603
00604 virtual MethodBase::pointer clone()
00605 { return MethodBase::pointer( new Method(this->name()) ); }
00606
00608 virtual std::string introspect(int space_depth=0) const
00609 {
00610 std::ostringstream sout;
00611 std::string spaces;
00612 for (int i=0; i < space_depth; i++ ) spaces += " ";
00613 sout << spaces << "<method name=\"" << name() << "\">\n";
00614
00615 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00616 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00617 sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00618 sout << spaces << " <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00619 sout << spaces << " <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
00620 sout << spaces << " <arg name=\"" << m_arg_names[6] << "\" type=\"" << signature<T_arg6>() << "\" direction=\"in\"/>\n";
00621 sout << spaces << "</method>\n";
00622 return sout.str();
00623 }
00624
00625 virtual std::string arg_name(size_t i) {
00626 if ( i < 6+1 ) return m_arg_names[i];
00627 return std::string();
00628 }
00629
00630 virtual void set_arg_name(size_t i, const std::string& name) {
00631 if ( i < 6+1 ) m_arg_names[i] = name;
00632 }
00633
00634 protected:
00635
00636 std::string m_arg_names[6+1];
00637
00638 sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
00639
00640 };
00641
00642
00643
00644 }
00645
00646 #endif