00001
00002
00003
00004
00005 #ifndef DBUS_CXX_METHOD_H
00006 #define DBUS_CXX_METHOD_H
00007
00008 #include <sstream>
00009 #include <dbus-cxx/methodbase.h>
00010
00011 namespace DBus {
00012
00013
00020 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>
00021 class Method
00022 : public MethodBase
00023 {
00024 public:
00025
00026 typedef DBusCxxPointer<Method> pointer;
00027
00028 Method(const std::string& name):
00029 MethodBase(name)
00030 { }
00031
00032 virtual ~Method() { }
00033
00034 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00035 {
00036 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 );
00037
00038 if ( not connection or not message ) return NOT_HANDLED;
00039
00040 T_return _retval;
00041
00042 T_arg1 _val_1;
00043 T_arg2 _val_2;
00044 T_arg3 _val_3;
00045 T_arg4 _val_4;
00046 T_arg5 _val_5;
00047 T_arg6 _val_6;
00048 T_arg7 _val_7;
00049
00050
00051 try {
00052 Message::iterator i = message->begin();
00053 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
00054 }
00055 catch ( ErrorInvalidTypecast& e ) {
00056 return NOT_HANDLED;
00057 }
00058
00059
00060 _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
00061
00062 ReturnMessage::pointer retmsg = message->create_reply();
00063
00064 if ( not retmsg ) return NOT_HANDLED;
00065
00066 *retmsg << _retval;
00067
00068 connection << retmsg;
00069
00070 return HANDLED;
00071 }
00072
00073 void set_method( sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot )
00074 { m_slot = slot; }
00075
00076 static pointer create(const std::string& name)
00077 { return pointer( new Method(name) ); }
00078
00079 virtual MethodBase::pointer clone()
00080 { return MethodBase::pointer( new Method(this->name()) ); }
00081
00083 virtual std::string introspect(int space_depth=0) const
00084 {
00085 std::ostringstream sout;
00086 std::string spaces;
00087 for (int i=0; i < space_depth; i++ ) spaces += " ";
00088 sout << spaces << "<method name=\"" << name() << "\">\n";
00089 sout << spaces << " <arg name=\"" << m_arg_names[0] << "\" type=\"" << signature<T_return>() << "\" direction=\"out\"/>\n";
00090
00091 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00092 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00093 sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00094 sout << spaces << " <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00095 sout << spaces << " <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
00096 sout << spaces << " <arg name=\"" << m_arg_names[6] << "\" type=\"" << signature<T_arg6>() << "\" direction=\"in\"/>\n";
00097 sout << spaces << " <arg name=\"" << m_arg_names[7] << "\" type=\"" << signature<T_arg7>() << "\" direction=\"in\"/>\n";
00098 sout << spaces << "</method>\n";
00099 return sout.str();
00100 }
00101
00102 virtual std::string arg_name(size_t i) {
00103 if ( i < 7+1 ) return m_arg_names[i];
00104 return std::string();
00105 }
00106
00107 virtual void set_arg_name(size_t i, const std::string& name) {
00108 if ( i < 7+1 ) m_arg_names[i] = name;
00109 }
00110
00111 protected:
00112
00113 std::string m_arg_names[7+1];
00114
00115 sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> m_slot;
00116
00117 };
00118
00119
00120
00127 template <class T_return>
00128 class Method <T_return, nil,nil,nil,nil,nil,nil,nil>
00129 : public MethodBase
00130 {
00131 public:
00132
00133 typedef DBusCxxPointer<Method> pointer;
00134
00135 Method(const std::string& name):
00136 MethodBase(name)
00137 { }
00138
00139 virtual ~Method() { }
00140
00141 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00142 {
00143 DBUS_CXX_DEBUG("Method<T_return>::handle_call_message method=" << m_name );
00144
00145 if ( not connection or not message ) return NOT_HANDLED;
00146
00147 T_return _retval;
00148
00149
00150
00151
00152 _retval = m_slot();
00153
00154 ReturnMessage::pointer retmsg = message->create_reply();
00155
00156 if ( not retmsg ) return NOT_HANDLED;
00157
00158 *retmsg << _retval;
00159
00160 connection << retmsg;
00161
00162 return HANDLED;
00163 }
00164
00165 void set_method( sigc::slot0<T_return> slot )
00166 { m_slot = slot; }
00167
00168 static pointer create(const std::string& name)
00169 { return pointer( new Method(name) ); }
00170
00171 virtual MethodBase::pointer clone()
00172 { return MethodBase::pointer( new Method(this->name()) ); }
00173
00175 virtual std::string introspect(int space_depth=0) const
00176 {
00177 std::ostringstream sout;
00178 std::string spaces;
00179 for (int i=0; i < space_depth; i++ ) spaces += " ";
00180 sout << spaces << "<method name=\"" << name() << "\">\n";
00181 sout << spaces << " <arg name=\"" << m_arg_names[0] << "\" type=\"" << signature<T_return>() << "\" direction=\"out\"/>\n";
00182
00183 sout << spaces << "</method>\n";
00184 return sout.str();
00185 }
00186
00187 virtual std::string arg_name(size_t i) {
00188 if ( i < 0+1 ) return m_arg_names[i];
00189 return std::string();
00190 }
00191
00192 virtual void set_arg_name(size_t i, const std::string& name) {
00193 if ( i < 0+1 ) m_arg_names[i] = name;
00194 }
00195
00196 protected:
00197
00198 std::string m_arg_names[0+1];
00199
00200 sigc::slot0<T_return> m_slot;
00201
00202 };
00203
00204
00211 template <class T_return, class T_arg1>
00212 class Method <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00213 : public MethodBase
00214 {
00215 public:
00216
00217 typedef DBusCxxPointer<Method> pointer;
00218
00219 Method(const std::string& name):
00220 MethodBase(name)
00221 { }
00222
00223 virtual ~Method() { }
00224
00225 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00226 {
00227 DBUS_CXX_DEBUG("Method<T_return, T_arg1>::handle_call_message method=" << m_name );
00228
00229 if ( not connection or not message ) return NOT_HANDLED;
00230
00231 T_return _retval;
00232
00233 T_arg1 _val_1;
00234
00235
00236 try {
00237 Message::iterator i = message->begin();
00238 i >> _val_1;
00239 }
00240 catch ( ErrorInvalidTypecast& e ) {
00241 return NOT_HANDLED;
00242 }
00243
00244
00245 _retval = m_slot(_val_1);
00246
00247 ReturnMessage::pointer retmsg = message->create_reply();
00248
00249 if ( not retmsg ) return NOT_HANDLED;
00250
00251 *retmsg << _retval;
00252
00253 connection << retmsg;
00254
00255 return HANDLED;
00256 }
00257
00258 void set_method( sigc::slot1<T_return, T_arg1> slot )
00259 { m_slot = slot; }
00260
00261 static pointer create(const std::string& name)
00262 { return pointer( new Method(name) ); }
00263
00264 virtual MethodBase::pointer clone()
00265 { return MethodBase::pointer( new Method(this->name()) ); }
00266
00268 virtual std::string introspect(int space_depth=0) const
00269 {
00270 std::ostringstream sout;
00271 std::string spaces;
00272 for (int i=0; i < space_depth; i++ ) spaces += " ";
00273 sout << spaces << "<method name=\"" << name() << "\">\n";
00274 sout << spaces << " <arg name=\"" << m_arg_names[0] << "\" type=\"" << signature<T_return>() << "\" direction=\"out\"/>\n";
00275
00276 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00277 sout << spaces << "</method>\n";
00278 return sout.str();
00279 }
00280
00281 virtual std::string arg_name(size_t i) {
00282 if ( i < 1+1 ) return m_arg_names[i];
00283 return std::string();
00284 }
00285
00286 virtual void set_arg_name(size_t i, const std::string& name) {
00287 if ( i < 1+1 ) m_arg_names[i] = name;
00288 }
00289
00290 protected:
00291
00292 std::string m_arg_names[1+1];
00293
00294 sigc::slot1<T_return, T_arg1> m_slot;
00295
00296 };
00297
00298
00305 template <class T_return, class T_arg1,class T_arg2>
00306 class Method <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00307 : public MethodBase
00308 {
00309 public:
00310
00311 typedef DBusCxxPointer<Method> pointer;
00312
00313 Method(const std::string& name):
00314 MethodBase(name)
00315 { }
00316
00317 virtual ~Method() { }
00318
00319 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00320 {
00321 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::handle_call_message method=" << m_name );
00322
00323 if ( not connection or not message ) return NOT_HANDLED;
00324
00325 T_return _retval;
00326
00327 T_arg1 _val_1;
00328 T_arg2 _val_2;
00329
00330
00331 try {
00332 Message::iterator i = message->begin();
00333 i >> _val_1 >> _val_2;
00334 }
00335 catch ( ErrorInvalidTypecast& e ) {
00336 return NOT_HANDLED;
00337 }
00338
00339
00340 _retval = m_slot(_val_1,_val_2);
00341
00342 ReturnMessage::pointer retmsg = message->create_reply();
00343
00344 if ( not retmsg ) return NOT_HANDLED;
00345
00346 *retmsg << _retval;
00347
00348 connection << retmsg;
00349
00350 return HANDLED;
00351 }
00352
00353 void set_method( sigc::slot2<T_return, T_arg1,T_arg2> slot )
00354 { m_slot = slot; }
00355
00356 static pointer create(const std::string& name)
00357 { return pointer( new Method(name) ); }
00358
00359 virtual MethodBase::pointer clone()
00360 { return MethodBase::pointer( new Method(this->name()) ); }
00361
00363 virtual std::string introspect(int space_depth=0) const
00364 {
00365 std::ostringstream sout;
00366 std::string spaces;
00367 for (int i=0; i < space_depth; i++ ) spaces += " ";
00368 sout << spaces << "<method name=\"" << name() << "\">\n";
00369 sout << spaces << " <arg name=\"" << m_arg_names[0] << "\" type=\"" << signature<T_return>() << "\" direction=\"out\"/>\n";
00370
00371 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00372 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00373 sout << spaces << "</method>\n";
00374 return sout.str();
00375 }
00376
00377 virtual std::string arg_name(size_t i) {
00378 if ( i < 2+1 ) return m_arg_names[i];
00379 return std::string();
00380 }
00381
00382 virtual void set_arg_name(size_t i, const std::string& name) {
00383 if ( i < 2+1 ) m_arg_names[i] = name;
00384 }
00385
00386 protected:
00387
00388 std::string m_arg_names[2+1];
00389
00390 sigc::slot2<T_return, T_arg1,T_arg2> m_slot;
00391
00392 };
00393
00394
00401 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00402 class Method <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00403 : public MethodBase
00404 {
00405 public:
00406
00407 typedef DBusCxxPointer<Method> pointer;
00408
00409 Method(const std::string& name):
00410 MethodBase(name)
00411 { }
00412
00413 virtual ~Method() { }
00414
00415 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00416 {
00417 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::handle_call_message method=" << m_name );
00418
00419 if ( not connection or not message ) return NOT_HANDLED;
00420
00421 T_return _retval;
00422
00423 T_arg1 _val_1;
00424 T_arg2 _val_2;
00425 T_arg3 _val_3;
00426
00427
00428 try {
00429 Message::iterator i = message->begin();
00430 i >> _val_1 >> _val_2 >> _val_3;
00431 }
00432 catch ( ErrorInvalidTypecast& e ) {
00433 return NOT_HANDLED;
00434 }
00435
00436
00437 _retval = m_slot(_val_1,_val_2,_val_3);
00438
00439 ReturnMessage::pointer retmsg = message->create_reply();
00440
00441 if ( not retmsg ) return NOT_HANDLED;
00442
00443 *retmsg << _retval;
00444
00445 connection << retmsg;
00446
00447 return HANDLED;
00448 }
00449
00450 void set_method( sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> slot )
00451 { m_slot = slot; }
00452
00453 static pointer create(const std::string& name)
00454 { return pointer( new Method(name) ); }
00455
00456 virtual MethodBase::pointer clone()
00457 { return MethodBase::pointer( new Method(this->name()) ); }
00458
00460 virtual std::string introspect(int space_depth=0) const
00461 {
00462 std::ostringstream sout;
00463 std::string spaces;
00464 for (int i=0; i < space_depth; i++ ) spaces += " ";
00465 sout << spaces << "<method name=\"" << name() << "\">\n";
00466 sout << spaces << " <arg name=\"" << m_arg_names[0] << "\" type=\"" << signature<T_return>() << "\" direction=\"out\"/>\n";
00467
00468 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00469 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00470 sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00471 sout << spaces << "</method>\n";
00472 return sout.str();
00473 }
00474
00475 virtual std::string arg_name(size_t i) {
00476 if ( i < 3+1 ) return m_arg_names[i];
00477 return std::string();
00478 }
00479
00480 virtual void set_arg_name(size_t i, const std::string& name) {
00481 if ( i < 3+1 ) m_arg_names[i] = name;
00482 }
00483
00484 protected:
00485
00486 std::string m_arg_names[3+1];
00487
00488 sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> m_slot;
00489
00490 };
00491
00492
00499 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00500 class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00501 : public MethodBase
00502 {
00503 public:
00504
00505 typedef DBusCxxPointer<Method> pointer;
00506
00507 Method(const std::string& name):
00508 MethodBase(name)
00509 { }
00510
00511 virtual ~Method() { }
00512
00513 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00514 {
00515 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message method=" << m_name );
00516
00517 if ( not connection or not message ) return NOT_HANDLED;
00518
00519 T_return _retval;
00520
00521 T_arg1 _val_1;
00522 T_arg2 _val_2;
00523 T_arg3 _val_3;
00524 T_arg4 _val_4;
00525
00526
00527 try {
00528 Message::iterator i = message->begin();
00529 i >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00530 }
00531 catch ( ErrorInvalidTypecast& e ) {
00532 return NOT_HANDLED;
00533 }
00534
00535
00536 _retval = m_slot(_val_1,_val_2,_val_3,_val_4);
00537
00538 ReturnMessage::pointer retmsg = message->create_reply();
00539
00540 if ( not retmsg ) return NOT_HANDLED;
00541
00542 *retmsg << _retval;
00543
00544 connection << retmsg;
00545
00546 return HANDLED;
00547 }
00548
00549 void set_method( sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00550 { m_slot = slot; }
00551
00552 static pointer create(const std::string& name)
00553 { return pointer( new Method(name) ); }
00554
00555 virtual MethodBase::pointer clone()
00556 { return MethodBase::pointer( new Method(this->name()) ); }
00557
00559 virtual std::string introspect(int space_depth=0) const
00560 {
00561 std::ostringstream sout;
00562 std::string spaces;
00563 for (int i=0; i < space_depth; i++ ) spaces += " ";
00564 sout << spaces << "<method name=\"" << name() << "\">\n";
00565 sout << spaces << " <arg name=\"" << m_arg_names[0] << "\" type=\"" << signature<T_return>() << "\" direction=\"out\"/>\n";
00566
00567 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00568 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00569 sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00570 sout << spaces << " <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00571 sout << spaces << "</method>\n";
00572 return sout.str();
00573 }
00574
00575 virtual std::string arg_name(size_t i) {
00576 if ( i < 4+1 ) return m_arg_names[i];
00577 return std::string();
00578 }
00579
00580 virtual void set_arg_name(size_t i, const std::string& name) {
00581 if ( i < 4+1 ) m_arg_names[i] = name;
00582 }
00583
00584 protected:
00585
00586 std::string m_arg_names[4+1];
00587
00588 sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
00589
00590 };
00591
00592
00599 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00600 class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00601 : public MethodBase
00602 {
00603 public:
00604
00605 typedef DBusCxxPointer<Method> pointer;
00606
00607 Method(const std::string& name):
00608 MethodBase(name)
00609 { }
00610
00611 virtual ~Method() { }
00612
00613 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00614 {
00615 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message method=" << m_name );
00616
00617 if ( not connection or not message ) return NOT_HANDLED;
00618
00619 T_return _retval;
00620
00621 T_arg1 _val_1;
00622 T_arg2 _val_2;
00623 T_arg3 _val_3;
00624 T_arg4 _val_4;
00625 T_arg5 _val_5;
00626
00627
00628 try {
00629 Message::iterator i = message->begin();
00630 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
00631 }
00632 catch ( ErrorInvalidTypecast& e ) {
00633 return NOT_HANDLED;
00634 }
00635
00636
00637 _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
00638
00639 ReturnMessage::pointer retmsg = message->create_reply();
00640
00641 if ( not retmsg ) return NOT_HANDLED;
00642
00643 *retmsg << _retval;
00644
00645 connection << retmsg;
00646
00647 return HANDLED;
00648 }
00649
00650 void set_method( sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
00651 { m_slot = slot; }
00652
00653 static pointer create(const std::string& name)
00654 { return pointer( new Method(name) ); }
00655
00656 virtual MethodBase::pointer clone()
00657 { return MethodBase::pointer( new Method(this->name()) ); }
00658
00660 virtual std::string introspect(int space_depth=0) const
00661 {
00662 std::ostringstream sout;
00663 std::string spaces;
00664 for (int i=0; i < space_depth; i++ ) spaces += " ";
00665 sout << spaces << "<method name=\"" << name() << "\">\n";
00666 sout << spaces << " <arg name=\"" << m_arg_names[0] << "\" type=\"" << signature<T_return>() << "\" direction=\"out\"/>\n";
00667
00668 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00669 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00670 sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00671 sout << spaces << " <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00672 sout << spaces << " <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
00673 sout << spaces << "</method>\n";
00674 return sout.str();
00675 }
00676
00677 virtual std::string arg_name(size_t i) {
00678 if ( i < 5+1 ) return m_arg_names[i];
00679 return std::string();
00680 }
00681
00682 virtual void set_arg_name(size_t i, const std::string& name) {
00683 if ( i < 5+1 ) m_arg_names[i] = name;
00684 }
00685
00686 protected:
00687
00688 std::string m_arg_names[5+1];
00689
00690 sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
00691
00692 };
00693
00694
00701 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00702 class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00703 : public MethodBase
00704 {
00705 public:
00706
00707 typedef DBusCxxPointer<Method> pointer;
00708
00709 Method(const std::string& name):
00710 MethodBase(name)
00711 { }
00712
00713 virtual ~Method() { }
00714
00715 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00716 {
00717 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message method=" << m_name );
00718
00719 if ( not connection or not message ) return NOT_HANDLED;
00720
00721 T_return _retval;
00722
00723 T_arg1 _val_1;
00724 T_arg2 _val_2;
00725 T_arg3 _val_3;
00726 T_arg4 _val_4;
00727 T_arg5 _val_5;
00728 T_arg6 _val_6;
00729
00730
00731 try {
00732 Message::iterator i = message->begin();
00733 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
00734 }
00735 catch ( ErrorInvalidTypecast& e ) {
00736 return NOT_HANDLED;
00737 }
00738
00739
00740 _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
00741
00742 ReturnMessage::pointer retmsg = message->create_reply();
00743
00744 if ( not retmsg ) return NOT_HANDLED;
00745
00746 *retmsg << _retval;
00747
00748 connection << retmsg;
00749
00750 return HANDLED;
00751 }
00752
00753 void set_method( sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
00754 { m_slot = slot; }
00755
00756 static pointer create(const std::string& name)
00757 { return pointer( new Method(name) ); }
00758
00759 virtual MethodBase::pointer clone()
00760 { return MethodBase::pointer( new Method(this->name()) ); }
00761
00763 virtual std::string introspect(int space_depth=0) const
00764 {
00765 std::ostringstream sout;
00766 std::string spaces;
00767 for (int i=0; i < space_depth; i++ ) spaces += " ";
00768 sout << spaces << "<method name=\"" << name() << "\">\n";
00769 sout << spaces << " <arg name=\"" << m_arg_names[0] << "\" type=\"" << signature<T_return>() << "\" direction=\"out\"/>\n";
00770
00771 sout << spaces << " <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00772 sout << spaces << " <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00773 sout << spaces << " <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00774 sout << spaces << " <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00775 sout << spaces << " <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
00776 sout << spaces << " <arg name=\"" << m_arg_names[6] << "\" type=\"" << signature<T_arg6>() << "\" direction=\"in\"/>\n";
00777 sout << spaces << "</method>\n";
00778 return sout.str();
00779 }
00780
00781 virtual std::string arg_name(size_t i) {
00782 if ( i < 6+1 ) return m_arg_names[i];
00783 return std::string();
00784 }
00785
00786 virtual void set_arg_name(size_t i, const std::string& name) {
00787 if ( i < 6+1 ) m_arg_names[i] = name;
00788 }
00789
00790 protected:
00791
00792 std::string m_arg_names[6+1];
00793
00794 sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
00795
00796 };
00797
00798
00799
00800 }
00801
00802 #endif
00803