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