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