dbus-cxx logo

method.h

Go to the documentation of this file.
00001 
00002 // -*- c++ -*-
00003 /* Do not edit! -- generated file */
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 } /* namespace DBus */
00785 
00786 #endif /* DBUS_CXX_METHOD_H */
00787 

Generated on Mon Sep 21 10:59:27 2009 for dbus-cxx by doxygen 1.6.1