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 <dbus-cxx/methodbase.h>
00009     
00010 namespace DBus {
00011 
00012 
00019   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>
00020   class Method 
00021     : public MethodBase
00022   {
00023   public:
00024 
00025     typedef DBusCxxPointer<Method> pointer;
00026 
00027     Method(const std::string& name):
00028       MethodBase(name)
00029     {  }
00030 
00031     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00032     {
00033       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 );
00034       
00035       if ( not connection or not message ) return NOT_HANDLED;
00036 
00037       T_return _retval;
00038             
00039       T_arg1 _val_1;
00040       T_arg2 _val_2;
00041       T_arg3 _val_3;
00042       T_arg4 _val_4;
00043       T_arg5 _val_5;
00044       T_arg6 _val_6;
00045       T_arg7 _val_7;
00046 
00047       
00048       try {
00049         Message::iterator i = message->begin();
00050         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
00051       }
00052       catch ( ErrorInvalidTypecast& e ) {
00053           return NOT_HANDLED;
00054       }
00055       
00056 
00057       _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
00058 
00059       ReturnMessage::pointer retmsg = message->create_reply();
00060 
00061       if ( not retmsg ) return NOT_HANDLED;
00062 
00063       retmsg << _retval;
00064 
00065       connection << retmsg;
00066 
00067       return HANDLED;
00068     }
00069 
00070     void set_method( sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot )
00071     { m_slot = slot; }
00072 
00073     static pointer create(const std::string& name)
00074     { return pointer( new Method(name) ); }
00075 
00076     virtual MethodBase::pointer clone()
00077     { return MethodBase::pointer( new Method(this->name()) ); }
00078 
00079   protected:
00080 
00081     sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> m_slot;
00082 
00083   };
00084 
00085 
00086 
00093   template <class T_return>
00094   class Method <T_return, nil,nil,nil,nil,nil,nil,nil>
00095     : public MethodBase
00096   {
00097   public:
00098 
00099     typedef DBusCxxPointer<Method> pointer;
00100 
00101     Method(const std::string& name):
00102       MethodBase(name)
00103     {  }
00104 
00105     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00106     {
00107       DBUS_CXX_DEBUG("Method<T_return>::handle_call_message   method=" << m_name );
00108       
00109       if ( not connection or not message ) return NOT_HANDLED;
00110 
00111       T_return _retval;
00112             
00113 
00114       
00115 
00116       _retval = m_slot();
00117 
00118       ReturnMessage::pointer retmsg = message->create_reply();
00119 
00120       if ( not retmsg ) return NOT_HANDLED;
00121 
00122       retmsg << _retval;
00123 
00124       connection << retmsg;
00125 
00126       return HANDLED;
00127     }
00128 
00129     void set_method( sigc::slot0<T_return> slot )
00130     { m_slot = slot; }
00131 
00132     static pointer create(const std::string& name)
00133     { return pointer( new Method(name) ); }
00134 
00135     virtual MethodBase::pointer clone()
00136     { return MethodBase::pointer( new Method(this->name()) ); }
00137 
00138   protected:
00139 
00140     sigc::slot0<T_return> m_slot;
00141 
00142   };
00143 
00144 
00151   template <class T_return, class T_arg1>
00152   class Method <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00153     : public MethodBase
00154   {
00155   public:
00156 
00157     typedef DBusCxxPointer<Method> pointer;
00158 
00159     Method(const std::string& name):
00160       MethodBase(name)
00161     {  }
00162 
00163     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00164     {
00165       DBUS_CXX_DEBUG("Method<T_return, T_arg1>::handle_call_message   method=" << m_name );
00166       
00167       if ( not connection or not message ) return NOT_HANDLED;
00168 
00169       T_return _retval;
00170             
00171       T_arg1 _val_1;
00172 
00173       
00174       try {
00175         Message::iterator i = message->begin();
00176         i  >> _val_1;
00177       }
00178       catch ( ErrorInvalidTypecast& e ) {
00179           return NOT_HANDLED;
00180       }
00181       
00182 
00183       _retval = m_slot(_val_1);
00184 
00185       ReturnMessage::pointer retmsg = message->create_reply();
00186 
00187       if ( not retmsg ) return NOT_HANDLED;
00188 
00189       retmsg << _retval;
00190 
00191       connection << retmsg;
00192 
00193       return HANDLED;
00194     }
00195 
00196     void set_method( sigc::slot1<T_return, T_arg1> slot )
00197     { m_slot = slot; }
00198 
00199     static pointer create(const std::string& name)
00200     { return pointer( new Method(name) ); }
00201 
00202     virtual MethodBase::pointer clone()
00203     { return MethodBase::pointer( new Method(this->name()) ); }
00204 
00205   protected:
00206 
00207     sigc::slot1<T_return, T_arg1> m_slot;
00208 
00209   };
00210 
00211 
00218   template <class T_return, class T_arg1,class T_arg2>
00219   class Method <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00220     : public MethodBase
00221   {
00222   public:
00223 
00224     typedef DBusCxxPointer<Method> pointer;
00225 
00226     Method(const std::string& name):
00227       MethodBase(name)
00228     {  }
00229 
00230     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00231     {
00232       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::handle_call_message   method=" << m_name );
00233       
00234       if ( not connection or not message ) return NOT_HANDLED;
00235 
00236       T_return _retval;
00237             
00238       T_arg1 _val_1;
00239       T_arg2 _val_2;
00240 
00241       
00242       try {
00243         Message::iterator i = message->begin();
00244         i  >> _val_1 >> _val_2;
00245       }
00246       catch ( ErrorInvalidTypecast& e ) {
00247           return NOT_HANDLED;
00248       }
00249       
00250 
00251       _retval = m_slot(_val_1,_val_2);
00252 
00253       ReturnMessage::pointer retmsg = message->create_reply();
00254 
00255       if ( not retmsg ) return NOT_HANDLED;
00256 
00257       retmsg << _retval;
00258 
00259       connection << retmsg;
00260 
00261       return HANDLED;
00262     }
00263 
00264     void set_method( sigc::slot2<T_return, T_arg1,T_arg2> slot )
00265     { m_slot = slot; }
00266 
00267     static pointer create(const std::string& name)
00268     { return pointer( new Method(name) ); }
00269 
00270     virtual MethodBase::pointer clone()
00271     { return MethodBase::pointer( new Method(this->name()) ); }
00272 
00273   protected:
00274 
00275     sigc::slot2<T_return, T_arg1,T_arg2> m_slot;
00276 
00277   };
00278 
00279 
00286   template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00287   class Method <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00288     : public MethodBase
00289   {
00290   public:
00291 
00292     typedef DBusCxxPointer<Method> pointer;
00293 
00294     Method(const std::string& name):
00295       MethodBase(name)
00296     {  }
00297 
00298     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00299     {
00300       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::handle_call_message   method=" << m_name );
00301       
00302       if ( not connection or not message ) return NOT_HANDLED;
00303 
00304       T_return _retval;
00305             
00306       T_arg1 _val_1;
00307       T_arg2 _val_2;
00308       T_arg3 _val_3;
00309 
00310       
00311       try {
00312         Message::iterator i = message->begin();
00313         i  >> _val_1 >> _val_2 >> _val_3;
00314       }
00315       catch ( ErrorInvalidTypecast& e ) {
00316           return NOT_HANDLED;
00317       }
00318       
00319 
00320       _retval = m_slot(_val_1,_val_2,_val_3);
00321 
00322       ReturnMessage::pointer retmsg = message->create_reply();
00323 
00324       if ( not retmsg ) return NOT_HANDLED;
00325 
00326       retmsg << _retval;
00327 
00328       connection << retmsg;
00329 
00330       return HANDLED;
00331     }
00332 
00333     void set_method( sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> slot )
00334     { m_slot = slot; }
00335 
00336     static pointer create(const std::string& name)
00337     { return pointer( new Method(name) ); }
00338 
00339     virtual MethodBase::pointer clone()
00340     { return MethodBase::pointer( new Method(this->name()) ); }
00341 
00342   protected:
00343 
00344     sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> m_slot;
00345 
00346   };
00347 
00348 
00355   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00356   class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00357     : public MethodBase
00358   {
00359   public:
00360 
00361     typedef DBusCxxPointer<Method> pointer;
00362 
00363     Method(const std::string& name):
00364       MethodBase(name)
00365     {  }
00366 
00367     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00368     {
00369       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message   method=" << m_name );
00370       
00371       if ( not connection or not message ) return NOT_HANDLED;
00372 
00373       T_return _retval;
00374             
00375       T_arg1 _val_1;
00376       T_arg2 _val_2;
00377       T_arg3 _val_3;
00378       T_arg4 _val_4;
00379 
00380       
00381       try {
00382         Message::iterator i = message->begin();
00383         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00384       }
00385       catch ( ErrorInvalidTypecast& e ) {
00386           return NOT_HANDLED;
00387       }
00388       
00389 
00390       _retval = m_slot(_val_1,_val_2,_val_3,_val_4);
00391 
00392       ReturnMessage::pointer retmsg = message->create_reply();
00393 
00394       if ( not retmsg ) return NOT_HANDLED;
00395 
00396       retmsg << _retval;
00397 
00398       connection << retmsg;
00399 
00400       return HANDLED;
00401     }
00402 
00403     void set_method( sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00404     { m_slot = slot; }
00405 
00406     static pointer create(const std::string& name)
00407     { return pointer( new Method(name) ); }
00408 
00409     virtual MethodBase::pointer clone()
00410     { return MethodBase::pointer( new Method(this->name()) ); }
00411 
00412   protected:
00413 
00414     sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
00415 
00416   };
00417 
00418 
00425   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00426   class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00427     : public MethodBase
00428   {
00429   public:
00430 
00431     typedef DBusCxxPointer<Method> pointer;
00432 
00433     Method(const std::string& name):
00434       MethodBase(name)
00435     {  }
00436 
00437     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00438     {
00439       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message   method=" << m_name );
00440       
00441       if ( not connection or not message ) return NOT_HANDLED;
00442 
00443       T_return _retval;
00444             
00445       T_arg1 _val_1;
00446       T_arg2 _val_2;
00447       T_arg3 _val_3;
00448       T_arg4 _val_4;
00449       T_arg5 _val_5;
00450 
00451       
00452       try {
00453         Message::iterator i = message->begin();
00454         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
00455       }
00456       catch ( ErrorInvalidTypecast& e ) {
00457           return NOT_HANDLED;
00458       }
00459       
00460 
00461       _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
00462 
00463       ReturnMessage::pointer retmsg = message->create_reply();
00464 
00465       if ( not retmsg ) return NOT_HANDLED;
00466 
00467       retmsg << _retval;
00468 
00469       connection << retmsg;
00470 
00471       return HANDLED;
00472     }
00473 
00474     void set_method( sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
00475     { m_slot = slot; }
00476 
00477     static pointer create(const std::string& name)
00478     { return pointer( new Method(name) ); }
00479 
00480     virtual MethodBase::pointer clone()
00481     { return MethodBase::pointer( new Method(this->name()) ); }
00482 
00483   protected:
00484 
00485     sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
00486 
00487   };
00488 
00489 
00496   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00497   class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00498     : public MethodBase
00499   {
00500   public:
00501 
00502     typedef DBusCxxPointer<Method> pointer;
00503 
00504     Method(const std::string& name):
00505       MethodBase(name)
00506     {  }
00507 
00508     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00509     {
00510       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message   method=" << m_name );
00511       
00512       if ( not connection or not message ) return NOT_HANDLED;
00513 
00514       T_return _retval;
00515             
00516       T_arg1 _val_1;
00517       T_arg2 _val_2;
00518       T_arg3 _val_3;
00519       T_arg4 _val_4;
00520       T_arg5 _val_5;
00521       T_arg6 _val_6;
00522 
00523       
00524       try {
00525         Message::iterator i = message->begin();
00526         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
00527       }
00528       catch ( ErrorInvalidTypecast& e ) {
00529           return NOT_HANDLED;
00530       }
00531       
00532 
00533       _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
00534 
00535       ReturnMessage::pointer retmsg = message->create_reply();
00536 
00537       if ( not retmsg ) return NOT_HANDLED;
00538 
00539       retmsg << _retval;
00540 
00541       connection << retmsg;
00542 
00543       return HANDLED;
00544     }
00545 
00546     void set_method( sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
00547     { m_slot = slot; }
00548 
00549     static pointer create(const std::string& name)
00550     { return pointer( new Method(name) ); }
00551 
00552     virtual MethodBase::pointer clone()
00553     { return MethodBase::pointer( new Method(this->name()) ); }
00554 
00555   protected:
00556 
00557     sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
00558 
00559   };
00560 
00561 
00562 
00563 } /* namespace DBus */
00564 
00565 #endif /* DBUS_CXX_METHOD_H */
00566 

Generated on Thu May 28 16:50:50 2009 for dbus-cxx by doxygen 1.5.7.1