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

Generated on Wed Sep 30 11:14:36 2009 for dbus-cxx by doxygen 1.6.1