00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <sstream>
00024 #include <dbus-cxx/forward_decls.h>
00025 #include <dbus-cxx/methodbase.h>
00026 #include <dbus-cxx/utility.h>
00027
00028 #ifndef DBUSCXX_METHOD_H
00029 #define DBUSCXX_METHOD_H
00030
00031 namespace DBus {
00032
00039 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
00040 class Method
00041 : public MethodBase
00042 {
00043 public:
00044
00045 typedef DBusCxxPointer<Method> pointer;
00046
00047 Method(const std::string& name): MethodBase(name) { }
00048
00049 virtual ~Method() { }
00050
00051 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00052 CallMessage::const_pointer message );
00053
00054 void set_method( sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot )
00055 { m_slot = slot; }
00056
00057 static pointer create(const std::string& name)
00058 { return pointer( new Method(name) ); }
00059
00060 virtual MethodBase::pointer clone()
00061 { return MethodBase::pointer( new Method(this->name()) ); }
00062
00064 virtual std::string introspect(int space_depth=0) const
00065 {
00066 std::ostringstream sout;
00067 std::string spaces;
00068 for (int i=0; i < space_depth; i++ ) spaces += " ";
00069 sout << spaces << "<method name=\"" << name() << "\">\n";
00070 sout << spaces << " <arg name=\"" << m_arg_names[0]
00071 << "\" type=\"" << signature<T_return>()
00072 << "\" direction=\"out\"/>\n";
00073 sout << spaces << " <arg name=\"" << m_arg_names[1]
00074 << "\" type=\"" << signature<T_arg1>()
00075 << "\" direction=\"in\"/>\n";
00076 sout << spaces << " <arg name=\"" << m_arg_names[2]
00077 << "\" type=\"" << signature<T_arg2>()
00078 << "\" direction=\"in\"/>\n";
00079 sout << spaces << " <arg name=\"" << m_arg_names[3]
00080 << "\" type=\"" << signature<T_arg3>()
00081 << "\" direction=\"in\"/>\n";
00082 sout << spaces << " <arg name=\"" << m_arg_names[4]
00083 << "\" type=\"" << signature<T_arg4>()
00084 << "\" direction=\"in\"/>\n";
00085 sout << spaces << " <arg name=\"" << m_arg_names[5]
00086 << "\" type=\"" << signature<T_arg5>()
00087 << "\" direction=\"in\"/>\n";
00088 sout << spaces << " <arg name=\"" << m_arg_names[6]
00089 << "\" type=\"" << signature<T_arg6>()
00090 << "\" direction=\"in\"/>\n";
00091 sout << spaces << " <arg name=\"" << m_arg_names[7]
00092 << "\" type=\"" << signature<T_arg7>()
00093 << "\" direction=\"in\"/>\n";
00094 sout << spaces << "</method>\n";
00095 return sout.str();
00096 }
00097
00098 virtual std::string arg_name(size_t i) {
00099 if ( i < 7+1 ) return m_arg_names[i];
00100 return std::string();
00101 }
00102
00103 virtual void set_arg_name(size_t i, const std::string& name) {
00104 if ( i < 7+1 ) m_arg_names[i] = name;
00105 }
00106
00107 protected:
00108
00109 std::string m_arg_names[7+1];
00110
00111 sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> m_slot;
00112
00113 };
00114
00115
00122 template <class T_return>
00123 class Method <T_return, nil,nil,nil,nil,nil,nil,nil>
00124 : public MethodBase
00125 {
00126 public:
00127
00128 typedef DBusCxxPointer<Method> pointer;
00129
00130 Method(const std::string& name): MethodBase(name) { }
00131
00132 virtual ~Method() { }
00133
00134 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00135 CallMessage::const_pointer message );
00136
00137 void set_method( sigc::slot0<T_return> slot )
00138 { m_slot = slot; }
00139
00140 static pointer create(const std::string& name)
00141 { return pointer( new Method(name) ); }
00142
00143 virtual MethodBase::pointer clone()
00144 { return MethodBase::pointer( new Method(this->name()) ); }
00145
00147 virtual std::string introspect(int space_depth=0) const
00148 {
00149 std::ostringstream sout;
00150 std::string spaces;
00151 for (int i=0; i < space_depth; i++ ) spaces += " ";
00152 sout << spaces << "<method name=\"" << name() << "\">\n";
00153 sout << spaces << " <arg name=\"" << m_arg_names[0]
00154 << "\" type=\"" << signature<T_return>()
00155 << "\" direction=\"out\"/>\n";
00156 sout << spaces << "</method>\n";
00157 return sout.str();
00158 }
00159
00160 virtual std::string arg_name(size_t i) {
00161 if ( i < 0+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 < 0+1 ) m_arg_names[i] = name;
00167 }
00168
00169 protected:
00170
00171 std::string m_arg_names[0+1];
00172
00173 sigc::slot0<T_return> m_slot;
00174
00175 };
00176
00183 template <class T_return, class T_arg1>
00184 class Method <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00185 : public MethodBase
00186 {
00187 public:
00188
00189 typedef DBusCxxPointer<Method> pointer;
00190
00191 Method(const std::string& name): MethodBase(name) { }
00192
00193 virtual ~Method() { }
00194
00195 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00196 CallMessage::const_pointer message );
00197
00198 void set_method( sigc::slot1<T_return, T_arg1> slot )
00199 { m_slot = slot; }
00200
00201 static pointer create(const std::string& name)
00202 { return pointer( new Method(name) ); }
00203
00204 virtual MethodBase::pointer clone()
00205 { return MethodBase::pointer( new Method(this->name()) ); }
00206
00208 virtual std::string introspect(int space_depth=0) const
00209 {
00210 std::ostringstream sout;
00211 std::string spaces;
00212 for (int i=0; i < space_depth; i++ ) spaces += " ";
00213 sout << spaces << "<method name=\"" << name() << "\">\n";
00214 sout << spaces << " <arg name=\"" << m_arg_names[0]
00215 << "\" type=\"" << signature<T_return>()
00216 << "\" direction=\"out\"/>\n";
00217 sout << spaces << " <arg name=\"" << m_arg_names[1]
00218 << "\" type=\"" << signature<T_arg1>()
00219 << "\" direction=\"in\"/>\n";
00220 sout << spaces << "</method>\n";
00221 return sout.str();
00222 }
00223
00224 virtual std::string arg_name(size_t i) {
00225 if ( i < 1+1 ) return m_arg_names[i];
00226 return std::string();
00227 }
00228
00229 virtual void set_arg_name(size_t i, const std::string& name) {
00230 if ( i < 1+1 ) m_arg_names[i] = name;
00231 }
00232
00233 protected:
00234
00235 std::string m_arg_names[1+1];
00236
00237 sigc::slot1<T_return, T_arg1> m_slot;
00238
00239 };
00240
00247 template <class T_return, class T_arg1,class T_arg2>
00248 class Method <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00249 : public MethodBase
00250 {
00251 public:
00252
00253 typedef DBusCxxPointer<Method> pointer;
00254
00255 Method(const std::string& name): MethodBase(name) { }
00256
00257 virtual ~Method() { }
00258
00259 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00260 CallMessage::const_pointer message );
00261
00262 void set_method( sigc::slot2<T_return, T_arg1,T_arg2> slot )
00263 { m_slot = slot; }
00264
00265 static pointer create(const std::string& name)
00266 { return pointer( new Method(name) ); }
00267
00268 virtual MethodBase::pointer clone()
00269 { return MethodBase::pointer( new Method(this->name()) ); }
00270
00272 virtual std::string introspect(int space_depth=0) const
00273 {
00274 std::ostringstream sout;
00275 std::string spaces;
00276 for (int i=0; i < space_depth; i++ ) spaces += " ";
00277 sout << spaces << "<method name=\"" << name() << "\">\n";
00278 sout << spaces << " <arg name=\"" << m_arg_names[0]
00279 << "\" type=\"" << signature<T_return>()
00280 << "\" direction=\"out\"/>\n";
00281 sout << spaces << " <arg name=\"" << m_arg_names[1]
00282 << "\" type=\"" << signature<T_arg1>()
00283 << "\" direction=\"in\"/>\n";
00284 sout << spaces << " <arg name=\"" << m_arg_names[2]
00285 << "\" type=\"" << signature<T_arg2>()
00286 << "\" direction=\"in\"/>\n";
00287 sout << spaces << "</method>\n";
00288 return sout.str();
00289 }
00290
00291 virtual std::string arg_name(size_t i) {
00292 if ( i < 2+1 ) return m_arg_names[i];
00293 return std::string();
00294 }
00295
00296 virtual void set_arg_name(size_t i, const std::string& name) {
00297 if ( i < 2+1 ) m_arg_names[i] = name;
00298 }
00299
00300 protected:
00301
00302 std::string m_arg_names[2+1];
00303
00304 sigc::slot2<T_return, T_arg1,T_arg2> m_slot;
00305
00306 };
00307
00314 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00315 class Method <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00316 : public MethodBase
00317 {
00318 public:
00319
00320 typedef DBusCxxPointer<Method> pointer;
00321
00322 Method(const std::string& name): MethodBase(name) { }
00323
00324 virtual ~Method() { }
00325
00326 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00327 CallMessage::const_pointer message );
00328
00329 void set_method( sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> slot )
00330 { m_slot = slot; }
00331
00332 static pointer create(const std::string& name)
00333 { return pointer( new Method(name) ); }
00334
00335 virtual MethodBase::pointer clone()
00336 { return MethodBase::pointer( new Method(this->name()) ); }
00337
00339 virtual std::string introspect(int space_depth=0) const
00340 {
00341 std::ostringstream sout;
00342 std::string spaces;
00343 for (int i=0; i < space_depth; i++ ) spaces += " ";
00344 sout << spaces << "<method name=\"" << name() << "\">\n";
00345 sout << spaces << " <arg name=\"" << m_arg_names[0]
00346 << "\" type=\"" << signature<T_return>()
00347 << "\" direction=\"out\"/>\n";
00348 sout << spaces << " <arg name=\"" << m_arg_names[1]
00349 << "\" type=\"" << signature<T_arg1>()
00350 << "\" direction=\"in\"/>\n";
00351 sout << spaces << " <arg name=\"" << m_arg_names[2]
00352 << "\" type=\"" << signature<T_arg2>()
00353 << "\" direction=\"in\"/>\n";
00354 sout << spaces << " <arg name=\"" << m_arg_names[3]
00355 << "\" type=\"" << signature<T_arg3>()
00356 << "\" direction=\"in\"/>\n";
00357 sout << spaces << "</method>\n";
00358 return sout.str();
00359 }
00360
00361 virtual std::string arg_name(size_t i) {
00362 if ( i < 3+1 ) return m_arg_names[i];
00363 return std::string();
00364 }
00365
00366 virtual void set_arg_name(size_t i, const std::string& name) {
00367 if ( i < 3+1 ) m_arg_names[i] = name;
00368 }
00369
00370 protected:
00371
00372 std::string m_arg_names[3+1];
00373
00374 sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> m_slot;
00375
00376 };
00377
00384 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00385 class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00386 : public MethodBase
00387 {
00388 public:
00389
00390 typedef DBusCxxPointer<Method> pointer;
00391
00392 Method(const std::string& name): MethodBase(name) { }
00393
00394 virtual ~Method() { }
00395
00396 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00397 CallMessage::const_pointer message );
00398
00399 void set_method( sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00400 { m_slot = slot; }
00401
00402 static pointer create(const std::string& name)
00403 { return pointer( new Method(name) ); }
00404
00405 virtual MethodBase::pointer clone()
00406 { return MethodBase::pointer( new Method(this->name()) ); }
00407
00409 virtual std::string introspect(int space_depth=0) const
00410 {
00411 std::ostringstream sout;
00412 std::string spaces;
00413 for (int i=0; i < space_depth; i++ ) spaces += " ";
00414 sout << spaces << "<method name=\"" << name() << "\">\n";
00415 sout << spaces << " <arg name=\"" << m_arg_names[0]
00416 << "\" type=\"" << signature<T_return>()
00417 << "\" direction=\"out\"/>\n";
00418 sout << spaces << " <arg name=\"" << m_arg_names[1]
00419 << "\" type=\"" << signature<T_arg1>()
00420 << "\" direction=\"in\"/>\n";
00421 sout << spaces << " <arg name=\"" << m_arg_names[2]
00422 << "\" type=\"" << signature<T_arg2>()
00423 << "\" direction=\"in\"/>\n";
00424 sout << spaces << " <arg name=\"" << m_arg_names[3]
00425 << "\" type=\"" << signature<T_arg3>()
00426 << "\" direction=\"in\"/>\n";
00427 sout << spaces << " <arg name=\"" << m_arg_names[4]
00428 << "\" type=\"" << signature<T_arg4>()
00429 << "\" direction=\"in\"/>\n";
00430 sout << spaces << "</method>\n";
00431 return sout.str();
00432 }
00433
00434 virtual std::string arg_name(size_t i) {
00435 if ( i < 4+1 ) return m_arg_names[i];
00436 return std::string();
00437 }
00438
00439 virtual void set_arg_name(size_t i, const std::string& name) {
00440 if ( i < 4+1 ) m_arg_names[i] = name;
00441 }
00442
00443 protected:
00444
00445 std::string m_arg_names[4+1];
00446
00447 sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
00448
00449 };
00450
00457 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00458 class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00459 : public MethodBase
00460 {
00461 public:
00462
00463 typedef DBusCxxPointer<Method> pointer;
00464
00465 Method(const std::string& name): MethodBase(name) { }
00466
00467 virtual ~Method() { }
00468
00469 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00470 CallMessage::const_pointer message );
00471
00472 void set_method( sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
00473 { m_slot = slot; }
00474
00475 static pointer create(const std::string& name)
00476 { return pointer( new Method(name) ); }
00477
00478 virtual MethodBase::pointer clone()
00479 { return MethodBase::pointer( new Method(this->name()) ); }
00480
00482 virtual std::string introspect(int space_depth=0) const
00483 {
00484 std::ostringstream sout;
00485 std::string spaces;
00486 for (int i=0; i < space_depth; i++ ) spaces += " ";
00487 sout << spaces << "<method name=\"" << name() << "\">\n";
00488 sout << spaces << " <arg name=\"" << m_arg_names[0]
00489 << "\" type=\"" << signature<T_return>()
00490 << "\" direction=\"out\"/>\n";
00491 sout << spaces << " <arg name=\"" << m_arg_names[1]
00492 << "\" type=\"" << signature<T_arg1>()
00493 << "\" direction=\"in\"/>\n";
00494 sout << spaces << " <arg name=\"" << m_arg_names[2]
00495 << "\" type=\"" << signature<T_arg2>()
00496 << "\" direction=\"in\"/>\n";
00497 sout << spaces << " <arg name=\"" << m_arg_names[3]
00498 << "\" type=\"" << signature<T_arg3>()
00499 << "\" direction=\"in\"/>\n";
00500 sout << spaces << " <arg name=\"" << m_arg_names[4]
00501 << "\" type=\"" << signature<T_arg4>()
00502 << "\" direction=\"in\"/>\n";
00503 sout << spaces << " <arg name=\"" << m_arg_names[5]
00504 << "\" type=\"" << signature<T_arg5>()
00505 << "\" direction=\"in\"/>\n";
00506 sout << spaces << "</method>\n";
00507 return sout.str();
00508 }
00509
00510 virtual std::string arg_name(size_t i) {
00511 if ( i < 5+1 ) return m_arg_names[i];
00512 return std::string();
00513 }
00514
00515 virtual void set_arg_name(size_t i, const std::string& name) {
00516 if ( i < 5+1 ) m_arg_names[i] = name;
00517 }
00518
00519 protected:
00520
00521 std::string m_arg_names[5+1];
00522
00523 sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
00524
00525 };
00526
00533 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00534 class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00535 : public MethodBase
00536 {
00537 public:
00538
00539 typedef DBusCxxPointer<Method> pointer;
00540
00541 Method(const std::string& name): MethodBase(name) { }
00542
00543 virtual ~Method() { }
00544
00545 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00546 CallMessage::const_pointer message );
00547
00548 void set_method( sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
00549 { m_slot = slot; }
00550
00551 static pointer create(const std::string& name)
00552 { return pointer( new Method(name) ); }
00553
00554 virtual MethodBase::pointer clone()
00555 { return MethodBase::pointer( new Method(this->name()) ); }
00556
00558 virtual std::string introspect(int space_depth=0) const
00559 {
00560 std::ostringstream sout;
00561 std::string spaces;
00562 for (int i=0; i < space_depth; i++ ) spaces += " ";
00563 sout << spaces << "<method name=\"" << name() << "\">\n";
00564 sout << spaces << " <arg name=\"" << m_arg_names[0]
00565 << "\" type=\"" << signature<T_return>()
00566 << "\" direction=\"out\"/>\n";
00567 sout << spaces << " <arg name=\"" << m_arg_names[1]
00568 << "\" type=\"" << signature<T_arg1>()
00569 << "\" direction=\"in\"/>\n";
00570 sout << spaces << " <arg name=\"" << m_arg_names[2]
00571 << "\" type=\"" << signature<T_arg2>()
00572 << "\" direction=\"in\"/>\n";
00573 sout << spaces << " <arg name=\"" << m_arg_names[3]
00574 << "\" type=\"" << signature<T_arg3>()
00575 << "\" direction=\"in\"/>\n";
00576 sout << spaces << " <arg name=\"" << m_arg_names[4]
00577 << "\" type=\"" << signature<T_arg4>()
00578 << "\" direction=\"in\"/>\n";
00579 sout << spaces << " <arg name=\"" << m_arg_names[5]
00580 << "\" type=\"" << signature<T_arg5>()
00581 << "\" direction=\"in\"/>\n";
00582 sout << spaces << " <arg name=\"" << m_arg_names[6]
00583 << "\" type=\"" << signature<T_arg6>()
00584 << "\" direction=\"in\"/>\n";
00585 sout << spaces << "</method>\n";
00586 return sout.str();
00587 }
00588
00589 virtual std::string arg_name(size_t i) {
00590 if ( i < 6+1 ) return m_arg_names[i];
00591 return std::string();
00592 }
00593
00594 virtual void set_arg_name(size_t i, const std::string& name) {
00595 if ( i < 6+1 ) m_arg_names[i] = name;
00596 }
00597
00598 protected:
00599
00600 std::string m_arg_names[6+1];
00601
00602 sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
00603
00604 };
00605
00606
00613 template <>
00614 class Method <void, nil,nil,nil,nil,nil,nil,nil>
00615 : public MethodBase
00616 {
00617 public:
00618
00619 typedef DBusCxxPointer<Method> pointer;
00620
00621 Method(const std::string& name): MethodBase(name) { }
00622
00623 virtual ~Method() { }
00624
00625 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00626 CallMessage::const_pointer message )
00627 {
00628 DBUS_CXX_DEBUG("Method<T_return>::handle_call_message method=" << m_name );
00629
00630 if ( not connection or not message ) return NOT_HANDLED;
00631
00632
00633
00634 m_slot();
00635
00636 return HANDLED;
00637 }
00638
00639
00640
00641 void set_method( sigc::slot0<void> slot )
00642 { m_slot = slot; }
00643
00644 static pointer create(const std::string& name)
00645 { return pointer( new Method(name) ); }
00646
00647 virtual MethodBase::pointer clone()
00648 { return MethodBase::pointer( new Method(this->name()) ); }
00649
00651 virtual std::string introspect(int space_depth=0) const
00652 {
00653 std::ostringstream sout;
00654 std::string spaces;
00655 for (int i=0; i < space_depth; i++ ) spaces += " ";
00656 sout << spaces << "<method name=\"" << name() << "\">\n";
00657 sout << spaces << "</method>\n";
00658 return sout.str();
00659 }
00660
00661 virtual std::string arg_name(size_t i) {
00662 if ( i < 0+1 ) return m_arg_names[i];
00663 return std::string();
00664 }
00665
00666 virtual void set_arg_name(size_t i, const std::string& name) {
00667 if ( i < 0+1 ) m_arg_names[i] = name;
00668 }
00669
00670 protected:
00671
00672 std::string m_arg_names[0+1];
00673
00674 sigc::slot0<void> m_slot;
00675
00676 };
00677
00684 template <class T_arg1>
00685 class Method <void, T_arg1, nil,nil,nil,nil,nil,nil>
00686 : public MethodBase
00687 {
00688 public:
00689
00690 typedef DBusCxxPointer<Method> pointer;
00691
00692 Method(const std::string& name): MethodBase(name) { }
00693
00694 virtual ~Method() { }
00695
00696 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00697 CallMessage::const_pointer message )
00698 {
00699 DBUS_CXX_DEBUG("Method<T_return, T_arg1>::handle_call_message method=" << m_name );
00700
00701 if ( not connection or not message ) return NOT_HANDLED;
00702
00703 T_arg1 _val_1;
00704
00705 try {
00706 Message::iterator i = message->begin();
00707 i >> _val_1;
00708 }
00709 catch ( ErrorInvalidTypecast& e ) {
00710 return NOT_HANDLED;
00711 }
00712
00713 m_slot(_val_1);
00714
00715 return HANDLED;
00716 }
00717
00718
00719
00720 void set_method( sigc::slot1<void, T_arg1> slot )
00721 { m_slot = slot; }
00722
00723 static pointer create(const std::string& name)
00724 { return pointer( new Method(name) ); }
00725
00726 virtual MethodBase::pointer clone()
00727 { return MethodBase::pointer( new Method(this->name()) ); }
00728
00730 virtual std::string introspect(int space_depth=0) const
00731 {
00732 std::ostringstream sout;
00733 std::string spaces;
00734 for (int i=0; i < space_depth; i++ ) spaces += " ";
00735 sout << spaces << "<method name=\"" << name() << "\">\n";
00736 sout << spaces << " <arg name=\"" << m_arg_names[1]
00737 << "\" type=\"" << signature<T_arg1>()
00738 << "\" direction=\"in\"/>\n";
00739 sout << spaces << "</method>\n";
00740 return sout.str();
00741 }
00742
00743 virtual std::string arg_name(size_t i) {
00744 if ( i < 1+1 ) return m_arg_names[i];
00745 return std::string();
00746 }
00747
00748 virtual void set_arg_name(size_t i, const std::string& name) {
00749 if ( i < 1+1 ) m_arg_names[i] = name;
00750 }
00751
00752 protected:
00753
00754 std::string m_arg_names[1+1];
00755
00756 sigc::slot1<void, T_arg1> m_slot;
00757
00758 };
00759
00766 template <class T_arg1,class T_arg2>
00767 class Method <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00768 : public MethodBase
00769 {
00770 public:
00771
00772 typedef DBusCxxPointer<Method> pointer;
00773
00774 Method(const std::string& name): MethodBase(name) { }
00775
00776 virtual ~Method() { }
00777
00778 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00779 CallMessage::const_pointer message )
00780 {
00781 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::handle_call_message method=" << m_name );
00782
00783 if ( not connection or not message ) return NOT_HANDLED;
00784
00785 T_arg1 _val_1;
00786 T_arg2 _val_2;
00787
00788 try {
00789 Message::iterator i = message->begin();
00790 i >> _val_1 >> _val_2;
00791 }
00792 catch ( ErrorInvalidTypecast& e ) {
00793 return NOT_HANDLED;
00794 }
00795
00796 m_slot(_val_1,_val_2);
00797
00798 return HANDLED;
00799 }
00800
00801
00802
00803 void set_method( sigc::slot2<void, T_arg1,T_arg2> slot )
00804 { m_slot = slot; }
00805
00806 static pointer create(const std::string& name)
00807 { return pointer( new Method(name) ); }
00808
00809 virtual MethodBase::pointer clone()
00810 { return MethodBase::pointer( new Method(this->name()) ); }
00811
00813 virtual std::string introspect(int space_depth=0) const
00814 {
00815 std::ostringstream sout;
00816 std::string spaces;
00817 for (int i=0; i < space_depth; i++ ) spaces += " ";
00818 sout << spaces << "<method name=\"" << name() << "\">\n";
00819 sout << spaces << " <arg name=\"" << m_arg_names[1]
00820 << "\" type=\"" << signature<T_arg1>()
00821 << "\" direction=\"in\"/>\n";
00822 sout << spaces << " <arg name=\"" << m_arg_names[2]
00823 << "\" type=\"" << signature<T_arg2>()
00824 << "\" direction=\"in\"/>\n";
00825 sout << spaces << "</method>\n";
00826 return sout.str();
00827 }
00828
00829 virtual std::string arg_name(size_t i) {
00830 if ( i < 2+1 ) return m_arg_names[i];
00831 return std::string();
00832 }
00833
00834 virtual void set_arg_name(size_t i, const std::string& name) {
00835 if ( i < 2+1 ) m_arg_names[i] = name;
00836 }
00837
00838 protected:
00839
00840 std::string m_arg_names[2+1];
00841
00842 sigc::slot2<void, T_arg1,T_arg2> m_slot;
00843
00844 };
00845
00852 template <class T_arg1,class T_arg2,class T_arg3>
00853 class Method <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00854 : public MethodBase
00855 {
00856 public:
00857
00858 typedef DBusCxxPointer<Method> pointer;
00859
00860 Method(const std::string& name): MethodBase(name) { }
00861
00862 virtual ~Method() { }
00863
00864 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00865 CallMessage::const_pointer message )
00866 {
00867 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::handle_call_message method=" << m_name );
00868
00869 if ( not connection or not message ) return NOT_HANDLED;
00870
00871 T_arg1 _val_1;
00872 T_arg2 _val_2;
00873 T_arg3 _val_3;
00874
00875 try {
00876 Message::iterator i = message->begin();
00877 i >> _val_1 >> _val_2 >> _val_3;
00878 }
00879 catch ( ErrorInvalidTypecast& e ) {
00880 return NOT_HANDLED;
00881 }
00882
00883 m_slot(_val_1,_val_2,_val_3);
00884
00885 return HANDLED;
00886 }
00887
00888
00889
00890 void set_method( sigc::slot3<void, T_arg1,T_arg2,T_arg3> slot )
00891 { m_slot = slot; }
00892
00893 static pointer create(const std::string& name)
00894 { return pointer( new Method(name) ); }
00895
00896 virtual MethodBase::pointer clone()
00897 { return MethodBase::pointer( new Method(this->name()) ); }
00898
00900 virtual std::string introspect(int space_depth=0) const
00901 {
00902 std::ostringstream sout;
00903 std::string spaces;
00904 for (int i=0; i < space_depth; i++ ) spaces += " ";
00905 sout << spaces << "<method name=\"" << name() << "\">\n";
00906 sout << spaces << " <arg name=\"" << m_arg_names[1]
00907 << "\" type=\"" << signature<T_arg1>()
00908 << "\" direction=\"in\"/>\n";
00909 sout << spaces << " <arg name=\"" << m_arg_names[2]
00910 << "\" type=\"" << signature<T_arg2>()
00911 << "\" direction=\"in\"/>\n";
00912 sout << spaces << " <arg name=\"" << m_arg_names[3]
00913 << "\" type=\"" << signature<T_arg3>()
00914 << "\" direction=\"in\"/>\n";
00915 sout << spaces << "</method>\n";
00916 return sout.str();
00917 }
00918
00919 virtual std::string arg_name(size_t i) {
00920 if ( i < 3+1 ) return m_arg_names[i];
00921 return std::string();
00922 }
00923
00924 virtual void set_arg_name(size_t i, const std::string& name) {
00925 if ( i < 3+1 ) m_arg_names[i] = name;
00926 }
00927
00928 protected:
00929
00930 std::string m_arg_names[3+1];
00931
00932 sigc::slot3<void, T_arg1,T_arg2,T_arg3> m_slot;
00933
00934 };
00935
00942 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00943 class Method <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00944 : public MethodBase
00945 {
00946 public:
00947
00948 typedef DBusCxxPointer<Method> pointer;
00949
00950 Method(const std::string& name): MethodBase(name) { }
00951
00952 virtual ~Method() { }
00953
00954 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00955 CallMessage::const_pointer message )
00956 {
00957 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message method=" << m_name );
00958
00959 if ( not connection or not message ) return NOT_HANDLED;
00960
00961 T_arg1 _val_1;
00962 T_arg2 _val_2;
00963 T_arg3 _val_3;
00964 T_arg4 _val_4;
00965
00966 try {
00967 Message::iterator i = message->begin();
00968 i >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00969 }
00970 catch ( ErrorInvalidTypecast& e ) {
00971 return NOT_HANDLED;
00972 }
00973
00974 m_slot(_val_1,_val_2,_val_3,_val_4);
00975
00976 return HANDLED;
00977 }
00978
00979
00980
00981 void set_method( sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00982 { m_slot = slot; }
00983
00984 static pointer create(const std::string& name)
00985 { return pointer( new Method(name) ); }
00986
00987 virtual MethodBase::pointer clone()
00988 { return MethodBase::pointer( new Method(this->name()) ); }
00989
00991 virtual std::string introspect(int space_depth=0) const
00992 {
00993 std::ostringstream sout;
00994 std::string spaces;
00995 for (int i=0; i < space_depth; i++ ) spaces += " ";
00996 sout << spaces << "<method name=\"" << name() << "\">\n";
00997 sout << spaces << " <arg name=\"" << m_arg_names[1]
00998 << "\" type=\"" << signature<T_arg1>()
00999 << "\" direction=\"in\"/>\n";
01000 sout << spaces << " <arg name=\"" << m_arg_names[2]
01001 << "\" type=\"" << signature<T_arg2>()
01002 << "\" direction=\"in\"/>\n";
01003 sout << spaces << " <arg name=\"" << m_arg_names[3]
01004 << "\" type=\"" << signature<T_arg3>()
01005 << "\" direction=\"in\"/>\n";
01006 sout << spaces << " <arg name=\"" << m_arg_names[4]
01007 << "\" type=\"" << signature<T_arg4>()
01008 << "\" direction=\"in\"/>\n";
01009 sout << spaces << "</method>\n";
01010 return sout.str();
01011 }
01012
01013 virtual std::string arg_name(size_t i) {
01014 if ( i < 4+1 ) return m_arg_names[i];
01015 return std::string();
01016 }
01017
01018 virtual void set_arg_name(size_t i, const std::string& name) {
01019 if ( i < 4+1 ) m_arg_names[i] = name;
01020 }
01021
01022 protected:
01023
01024 std::string m_arg_names[4+1];
01025
01026 sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
01027
01028 };
01029
01036 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
01037 class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
01038 : public MethodBase
01039 {
01040 public:
01041
01042 typedef DBusCxxPointer<Method> pointer;
01043
01044 Method(const std::string& name): MethodBase(name) { }
01045
01046 virtual ~Method() { }
01047
01048 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
01049 CallMessage::const_pointer message )
01050 {
01051 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message method=" << m_name );
01052
01053 if ( not connection or not message ) return NOT_HANDLED;
01054
01055 T_arg1 _val_1;
01056 T_arg2 _val_2;
01057 T_arg3 _val_3;
01058 T_arg4 _val_4;
01059 T_arg5 _val_5;
01060
01061 try {
01062 Message::iterator i = message->begin();
01063 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
01064 }
01065 catch ( ErrorInvalidTypecast& e ) {
01066 return NOT_HANDLED;
01067 }
01068
01069 m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
01070
01071 return HANDLED;
01072 }
01073
01074
01075
01076 void set_method( sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
01077 { m_slot = slot; }
01078
01079 static pointer create(const std::string& name)
01080 { return pointer( new Method(name) ); }
01081
01082 virtual MethodBase::pointer clone()
01083 { return MethodBase::pointer( new Method(this->name()) ); }
01084
01086 virtual std::string introspect(int space_depth=0) const
01087 {
01088 std::ostringstream sout;
01089 std::string spaces;
01090 for (int i=0; i < space_depth; i++ ) spaces += " ";
01091 sout << spaces << "<method name=\"" << name() << "\">\n";
01092 sout << spaces << " <arg name=\"" << m_arg_names[1]
01093 << "\" type=\"" << signature<T_arg1>()
01094 << "\" direction=\"in\"/>\n";
01095 sout << spaces << " <arg name=\"" << m_arg_names[2]
01096 << "\" type=\"" << signature<T_arg2>()
01097 << "\" direction=\"in\"/>\n";
01098 sout << spaces << " <arg name=\"" << m_arg_names[3]
01099 << "\" type=\"" << signature<T_arg3>()
01100 << "\" direction=\"in\"/>\n";
01101 sout << spaces << " <arg name=\"" << m_arg_names[4]
01102 << "\" type=\"" << signature<T_arg4>()
01103 << "\" direction=\"in\"/>\n";
01104 sout << spaces << " <arg name=\"" << m_arg_names[5]
01105 << "\" type=\"" << signature<T_arg5>()
01106 << "\" direction=\"in\"/>\n";
01107 sout << spaces << "</method>\n";
01108 return sout.str();
01109 }
01110
01111 virtual std::string arg_name(size_t i) {
01112 if ( i < 5+1 ) return m_arg_names[i];
01113 return std::string();
01114 }
01115
01116 virtual void set_arg_name(size_t i, const std::string& name) {
01117 if ( i < 5+1 ) m_arg_names[i] = name;
01118 }
01119
01120 protected:
01121
01122 std::string m_arg_names[5+1];
01123
01124 sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
01125
01126 };
01127
01134 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
01135 class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
01136 : public MethodBase
01137 {
01138 public:
01139
01140 typedef DBusCxxPointer<Method> pointer;
01141
01142 Method(const std::string& name): MethodBase(name) { }
01143
01144 virtual ~Method() { }
01145
01146 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
01147 CallMessage::const_pointer message )
01148 {
01149 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message method=" << m_name );
01150
01151 if ( not connection or not message ) return NOT_HANDLED;
01152
01153 T_arg1 _val_1;
01154 T_arg2 _val_2;
01155 T_arg3 _val_3;
01156 T_arg4 _val_4;
01157 T_arg5 _val_5;
01158 T_arg6 _val_6;
01159
01160 try {
01161 Message::iterator i = message->begin();
01162 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
01163 }
01164 catch ( ErrorInvalidTypecast& e ) {
01165 return NOT_HANDLED;
01166 }
01167
01168 m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
01169
01170 return HANDLED;
01171 }
01172
01173
01174
01175 void set_method( sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
01176 { m_slot = slot; }
01177
01178 static pointer create(const std::string& name)
01179 { return pointer( new Method(name) ); }
01180
01181 virtual MethodBase::pointer clone()
01182 { return MethodBase::pointer( new Method(this->name()) ); }
01183
01185 virtual std::string introspect(int space_depth=0) const
01186 {
01187 std::ostringstream sout;
01188 std::string spaces;
01189 for (int i=0; i < space_depth; i++ ) spaces += " ";
01190 sout << spaces << "<method name=\"" << name() << "\">\n";
01191 sout << spaces << " <arg name=\"" << m_arg_names[1]
01192 << "\" type=\"" << signature<T_arg1>()
01193 << "\" direction=\"in\"/>\n";
01194 sout << spaces << " <arg name=\"" << m_arg_names[2]
01195 << "\" type=\"" << signature<T_arg2>()
01196 << "\" direction=\"in\"/>\n";
01197 sout << spaces << " <arg name=\"" << m_arg_names[3]
01198 << "\" type=\"" << signature<T_arg3>()
01199 << "\" direction=\"in\"/>\n";
01200 sout << spaces << " <arg name=\"" << m_arg_names[4]
01201 << "\" type=\"" << signature<T_arg4>()
01202 << "\" direction=\"in\"/>\n";
01203 sout << spaces << " <arg name=\"" << m_arg_names[5]
01204 << "\" type=\"" << signature<T_arg5>()
01205 << "\" direction=\"in\"/>\n";
01206 sout << spaces << " <arg name=\"" << m_arg_names[6]
01207 << "\" type=\"" << signature<T_arg6>()
01208 << "\" direction=\"in\"/>\n";
01209 sout << spaces << "</method>\n";
01210 return sout.str();
01211 }
01212
01213 virtual std::string arg_name(size_t i) {
01214 if ( i < 6+1 ) return m_arg_names[i];
01215 return std::string();
01216 }
01217
01218 virtual void set_arg_name(size_t i, const std::string& name) {
01219 if ( i < 6+1 ) m_arg_names[i] = name;
01220 }
01221
01222 protected:
01223
01224 std::string m_arg_names[6+1];
01225
01226 sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
01227
01228 };
01229
01236 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
01237 class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
01238 : public MethodBase
01239 {
01240 public:
01241
01242 typedef DBusCxxPointer<Method> pointer;
01243
01244 Method(const std::string& name): MethodBase(name) { }
01245
01246 virtual ~Method() { }
01247
01248 virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
01249 CallMessage::const_pointer message )
01250 {
01251 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 );
01252
01253 if ( not connection or not message ) return NOT_HANDLED;
01254
01255 T_arg1 _val_1;
01256 T_arg2 _val_2;
01257 T_arg3 _val_3;
01258 T_arg4 _val_4;
01259 T_arg5 _val_5;
01260 T_arg6 _val_6;
01261 T_arg7 _val_7;
01262
01263 try {
01264 Message::iterator i = message->begin();
01265 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
01266 }
01267 catch ( ErrorInvalidTypecast& e ) {
01268 return NOT_HANDLED;
01269 }
01270
01271 m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
01272
01273 return HANDLED;
01274 }
01275
01276
01277
01278 void set_method( sigc::slot7<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot )
01279 { m_slot = slot; }
01280
01281 static pointer create(const std::string& name)
01282 { return pointer( new Method(name) ); }
01283
01284 virtual MethodBase::pointer clone()
01285 { return MethodBase::pointer( new Method(this->name()) ); }
01286
01288 virtual std::string introspect(int space_depth=0) const
01289 {
01290 std::ostringstream sout;
01291 std::string spaces;
01292 for (int i=0; i < space_depth; i++ ) spaces += " ";
01293 sout << spaces << "<method name=\"" << name() << "\">\n";
01294 sout << spaces << " <arg name=\"" << m_arg_names[1]
01295 << "\" type=\"" << signature<T_arg1>()
01296 << "\" direction=\"in\"/>\n";
01297 sout << spaces << " <arg name=\"" << m_arg_names[2]
01298 << "\" type=\"" << signature<T_arg2>()
01299 << "\" direction=\"in\"/>\n";
01300 sout << spaces << " <arg name=\"" << m_arg_names[3]
01301 << "\" type=\"" << signature<T_arg3>()
01302 << "\" direction=\"in\"/>\n";
01303 sout << spaces << " <arg name=\"" << m_arg_names[4]
01304 << "\" type=\"" << signature<T_arg4>()
01305 << "\" direction=\"in\"/>\n";
01306 sout << spaces << " <arg name=\"" << m_arg_names[5]
01307 << "\" type=\"" << signature<T_arg5>()
01308 << "\" direction=\"in\"/>\n";
01309 sout << spaces << " <arg name=\"" << m_arg_names[6]
01310 << "\" type=\"" << signature<T_arg6>()
01311 << "\" direction=\"in\"/>\n";
01312 sout << spaces << " <arg name=\"" << m_arg_names[7]
01313 << "\" type=\"" << signature<T_arg7>()
01314 << "\" direction=\"in\"/>\n";
01315 sout << spaces << "</method>\n";
01316 return sout.str();
01317 }
01318
01319 virtual std::string arg_name(size_t i) {
01320 if ( i < 7+1 ) return m_arg_names[i];
01321 return std::string();
01322 }
01323
01324 virtual void set_arg_name(size_t i, const std::string& name) {
01325 if ( i < 7+1 ) m_arg_names[i] = name;
01326 }
01327
01328 protected:
01329
01330 std::string m_arg_names[7+1];
01331
01332 sigc::slot7<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> m_slot;
01333
01334 };
01335
01336
01337
01338 }
01339
01340 #include <dbus-cxx/connection.h>
01341
01342 namespace DBus {
01343
01344 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
01345 HandlerResult Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01346 {
01347 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 );
01348
01349 if ( not connection or not message ) return NOT_HANDLED;
01350
01351 T_return _retval;
01352 T_arg1 _val_1;
01353 T_arg2 _val_2;
01354 T_arg3 _val_3;
01355 T_arg4 _val_4;
01356 T_arg5 _val_5;
01357 T_arg6 _val_6;
01358 T_arg7 _val_7;
01359
01360 try {
01361 Message::iterator i = message->begin();
01362 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
01363 }
01364 catch ( ErrorInvalidTypecast& e ) {
01365 return NOT_HANDLED;
01366 }
01367
01368 _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
01369 ReturnMessage::pointer retmsg = message->create_reply();
01370
01371 if ( not retmsg ) return NOT_HANDLED;
01372
01373 *retmsg << _retval;
01374
01375 connection->send(retmsg);
01376
01377 return HANDLED;
01378 }
01379
01380
01381
01382 template <class T_return>
01383 HandlerResult Method <T_return, nil,nil,nil,nil,nil,nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01384 {
01385 DBUS_CXX_DEBUG("Method<T_return>::handle_call_message method=" << m_name );
01386
01387 if ( not connection or not message ) return NOT_HANDLED;
01388
01389 T_return _retval;
01390
01391
01392 _retval = m_slot();
01393 ReturnMessage::pointer retmsg = message->create_reply();
01394
01395 if ( not retmsg ) return NOT_HANDLED;
01396
01397 *retmsg << _retval;
01398
01399 connection->send(retmsg);
01400
01401 return HANDLED;
01402 }
01403
01404
01405 template <class T_return, class T_arg1>
01406 HandlerResult Method <T_return, T_arg1, nil,nil,nil,nil,nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01407 {
01408 DBUS_CXX_DEBUG("Method<T_return, T_arg1>::handle_call_message method=" << m_name );
01409
01410 if ( not connection or not message ) return NOT_HANDLED;
01411
01412 T_return _retval;
01413 T_arg1 _val_1;
01414
01415 try {
01416 Message::iterator i = message->begin();
01417 i >> _val_1;
01418 }
01419 catch ( ErrorInvalidTypecast& e ) {
01420 return NOT_HANDLED;
01421 }
01422
01423 _retval = m_slot(_val_1);
01424 ReturnMessage::pointer retmsg = message->create_reply();
01425
01426 if ( not retmsg ) return NOT_HANDLED;
01427
01428 *retmsg << _retval;
01429
01430 connection->send(retmsg);
01431
01432 return HANDLED;
01433 }
01434
01435
01436 template <class T_return, class T_arg1,class T_arg2>
01437 HandlerResult Method <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01438 {
01439 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::handle_call_message method=" << m_name );
01440
01441 if ( not connection or not message ) return NOT_HANDLED;
01442
01443 T_return _retval;
01444 T_arg1 _val_1;
01445 T_arg2 _val_2;
01446
01447 try {
01448 Message::iterator i = message->begin();
01449 i >> _val_1 >> _val_2;
01450 }
01451 catch ( ErrorInvalidTypecast& e ) {
01452 return NOT_HANDLED;
01453 }
01454
01455 _retval = m_slot(_val_1,_val_2);
01456 ReturnMessage::pointer retmsg = message->create_reply();
01457
01458 if ( not retmsg ) return NOT_HANDLED;
01459
01460 *retmsg << _retval;
01461
01462 connection->send(retmsg);
01463
01464 return HANDLED;
01465 }
01466
01467
01468 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
01469 HandlerResult Method <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01470 {
01471 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::handle_call_message method=" << m_name );
01472
01473 if ( not connection or not message ) return NOT_HANDLED;
01474
01475 T_return _retval;
01476 T_arg1 _val_1;
01477 T_arg2 _val_2;
01478 T_arg3 _val_3;
01479
01480 try {
01481 Message::iterator i = message->begin();
01482 i >> _val_1 >> _val_2 >> _val_3;
01483 }
01484 catch ( ErrorInvalidTypecast& e ) {
01485 return NOT_HANDLED;
01486 }
01487
01488 _retval = m_slot(_val_1,_val_2,_val_3);
01489 ReturnMessage::pointer retmsg = message->create_reply();
01490
01491 if ( not retmsg ) return NOT_HANDLED;
01492
01493 *retmsg << _retval;
01494
01495 connection->send(retmsg);
01496
01497 return HANDLED;
01498 }
01499
01500
01501 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
01502 HandlerResult Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01503 {
01504 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message method=" << m_name );
01505
01506 if ( not connection or not message ) return NOT_HANDLED;
01507
01508 T_return _retval;
01509 T_arg1 _val_1;
01510 T_arg2 _val_2;
01511 T_arg3 _val_3;
01512 T_arg4 _val_4;
01513
01514 try {
01515 Message::iterator i = message->begin();
01516 i >> _val_1 >> _val_2 >> _val_3 >> _val_4;
01517 }
01518 catch ( ErrorInvalidTypecast& e ) {
01519 return NOT_HANDLED;
01520 }
01521
01522 _retval = m_slot(_val_1,_val_2,_val_3,_val_4);
01523 ReturnMessage::pointer retmsg = message->create_reply();
01524
01525 if ( not retmsg ) return NOT_HANDLED;
01526
01527 *retmsg << _retval;
01528
01529 connection->send(retmsg);
01530
01531 return HANDLED;
01532 }
01533
01534
01535 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
01536 HandlerResult Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01537 {
01538 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message method=" << m_name );
01539
01540 if ( not connection or not message ) return NOT_HANDLED;
01541
01542 T_return _retval;
01543 T_arg1 _val_1;
01544 T_arg2 _val_2;
01545 T_arg3 _val_3;
01546 T_arg4 _val_4;
01547 T_arg5 _val_5;
01548
01549 try {
01550 Message::iterator i = message->begin();
01551 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
01552 }
01553 catch ( ErrorInvalidTypecast& e ) {
01554 return NOT_HANDLED;
01555 }
01556
01557 _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
01558 ReturnMessage::pointer retmsg = message->create_reply();
01559
01560 if ( not retmsg ) return NOT_HANDLED;
01561
01562 *retmsg << _retval;
01563
01564 connection->send(retmsg);
01565
01566 return HANDLED;
01567 }
01568
01569
01570 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
01571 HandlerResult Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01572 {
01573 DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message method=" << m_name );
01574
01575 if ( not connection or not message ) return NOT_HANDLED;
01576
01577 T_return _retval;
01578 T_arg1 _val_1;
01579 T_arg2 _val_2;
01580 T_arg3 _val_3;
01581 T_arg4 _val_4;
01582 T_arg5 _val_5;
01583 T_arg6 _val_6;
01584
01585 try {
01586 Message::iterator i = message->begin();
01587 i >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
01588 }
01589 catch ( ErrorInvalidTypecast& e ) {
01590 return NOT_HANDLED;
01591 }
01592
01593 _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
01594 ReturnMessage::pointer retmsg = message->create_reply();
01595
01596 if ( not retmsg ) return NOT_HANDLED;
01597
01598 *retmsg << _retval;
01599
01600 connection->send(retmsg);
01601
01602 return HANDLED;
01603 }
01604
01605
01606
01607
01608 }
01609
01610 #endif
01611