dbus-cxx logo

method_impl.h

Go to the documentation of this file.
00001 
00002 // -*- c++ -*-
00003 /* Do not edit! -- generated file */
00004 
00005 #ifndef DBUS_CXX_METHOD_IMPL_H
00006 #define DBUS_CXX_METHOD_IMPL_H
00007 
00008 #include <dbus-cxx/method.h>
00009 #include <dbus-cxx/connection.h>
00010     
00011 namespace DBus {
00012 
00015   template <>
00016   class Method <void, nil,nil,nil,nil,nil,nil,nil>
00017     : public MethodBase
00018   {
00019   public:
00020 
00021     typedef DBusCxxPointer<Method> pointer;
00022 
00023     Method(const std::string& name):
00024       MethodBase(name)
00025     {  }
00026 
00027     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00028     {
00029       DBUS_CXX_DEBUG("Method<void>::handle_call_message   method=" << m_name );
00030       
00031       if ( not connection or not message ) return NOT_HANDLED;
00032 
00033             
00034 
00035       
00036 
00037       m_slot();
00038 
00039       ReturnMessage::const_pointer retmsg;
00040 
00041       if ( message->expects_reply() )
00042       {
00043         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00044         retmsg = message->create_reply();
00045         if ( not retmsg ) return NOT_HANDLED;
00046         connection << retmsg;
00047       }
00048 
00049       return HANDLED;
00050     }
00051 
00052     void set_method( sigc::slot0<void> slot )
00053     { m_slot = slot; }
00054 
00055     static pointer create(const std::string& name)
00056     { return pointer( new Method(name) ); }
00057 
00058     virtual MethodBase::pointer clone()
00059     { return MethodBase::pointer( new Method(this->name()) ); }
00060 
00061   protected:
00062 
00063     sigc::slot0<void> m_slot;
00064 
00065   };
00066 
00069   template <class T_arg1>
00070   class Method <void, T_arg1, nil,nil,nil,nil,nil,nil>
00071     : public MethodBase
00072   {
00073   public:
00074 
00075     typedef DBusCxxPointer<Method> pointer;
00076 
00077     Method(const std::string& name):
00078       MethodBase(name)
00079     {  }
00080 
00081     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00082     {
00083       DBUS_CXX_DEBUG("Method<void, T_arg1>::handle_call_message   method=" << m_name );
00084       
00085       if ( not connection or not message ) return NOT_HANDLED;
00086 
00087             
00088       T_arg1 _val_1;
00089 
00090       
00091       try {
00092         Message::iterator i = message->begin();
00093         i  >> _val_1;
00094       }
00095       catch ( ErrorInvalidTypecast& e ) {
00096           return NOT_HANDLED;
00097       }
00098       
00099 
00100       m_slot(_val_1);
00101 
00102       ReturnMessage::const_pointer retmsg;
00103 
00104       if ( message->expects_reply() )
00105       {
00106         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00107         retmsg = message->create_reply();
00108         if ( not retmsg ) return NOT_HANDLED;
00109         connection << retmsg;
00110       }
00111 
00112       return HANDLED;
00113     }
00114 
00115     void set_method( sigc::slot1<void, T_arg1> slot )
00116     { m_slot = slot; }
00117 
00118     static pointer create(const std::string& name)
00119     { return pointer( new Method(name) ); }
00120 
00121     virtual MethodBase::pointer clone()
00122     { return MethodBase::pointer( new Method(this->name()) ); }
00123 
00124   protected:
00125 
00126     sigc::slot1<void, T_arg1> m_slot;
00127 
00128   };
00129 
00132   template <class T_arg1,class T_arg2>
00133   class Method <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00134     : public MethodBase
00135   {
00136   public:
00137 
00138     typedef DBusCxxPointer<Method> pointer;
00139 
00140     Method(const std::string& name):
00141       MethodBase(name)
00142     {  }
00143 
00144     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00145     {
00146       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2>::handle_call_message   method=" << m_name );
00147       
00148       if ( not connection or not message ) return NOT_HANDLED;
00149 
00150             
00151       T_arg1 _val_1;
00152       T_arg2 _val_2;
00153 
00154       
00155       try {
00156         Message::iterator i = message->begin();
00157         i  >> _val_1 >> _val_2;
00158       }
00159       catch ( ErrorInvalidTypecast& e ) {
00160           return NOT_HANDLED;
00161       }
00162       
00163 
00164       m_slot(_val_1,_val_2);
00165 
00166       ReturnMessage::const_pointer retmsg;
00167 
00168       if ( message->expects_reply() )
00169       {
00170         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00171         retmsg = message->create_reply();
00172         if ( not retmsg ) return NOT_HANDLED;
00173         connection << retmsg;
00174       }
00175 
00176       return HANDLED;
00177     }
00178 
00179     void set_method( sigc::slot2<void, T_arg1,T_arg2> slot )
00180     { m_slot = slot; }
00181 
00182     static pointer create(const std::string& name)
00183     { return pointer( new Method(name) ); }
00184 
00185     virtual MethodBase::pointer clone()
00186     { return MethodBase::pointer( new Method(this->name()) ); }
00187 
00188   protected:
00189 
00190     sigc::slot2<void, T_arg1,T_arg2> m_slot;
00191 
00192   };
00193 
00196   template <class T_arg1,class T_arg2,class T_arg3>
00197   class Method <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00198     : public MethodBase
00199   {
00200   public:
00201 
00202     typedef DBusCxxPointer<Method> pointer;
00203 
00204     Method(const std::string& name):
00205       MethodBase(name)
00206     {  }
00207 
00208     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00209     {
00210       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3>::handle_call_message   method=" << m_name );
00211       
00212       if ( not connection or not message ) return NOT_HANDLED;
00213 
00214             
00215       T_arg1 _val_1;
00216       T_arg2 _val_2;
00217       T_arg3 _val_3;
00218 
00219       
00220       try {
00221         Message::iterator i = message->begin();
00222         i  >> _val_1 >> _val_2 >> _val_3;
00223       }
00224       catch ( ErrorInvalidTypecast& e ) {
00225           return NOT_HANDLED;
00226       }
00227       
00228 
00229       m_slot(_val_1,_val_2,_val_3);
00230 
00231       ReturnMessage::const_pointer retmsg;
00232 
00233       if ( message->expects_reply() )
00234       {
00235         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00236         retmsg = message->create_reply();
00237         if ( not retmsg ) return NOT_HANDLED;
00238         connection << retmsg;
00239       }
00240 
00241       return HANDLED;
00242     }
00243 
00244     void set_method( sigc::slot3<void, T_arg1,T_arg2,T_arg3> slot )
00245     { m_slot = slot; }
00246 
00247     static pointer create(const std::string& name)
00248     { return pointer( new Method(name) ); }
00249 
00250     virtual MethodBase::pointer clone()
00251     { return MethodBase::pointer( new Method(this->name()) ); }
00252 
00253   protected:
00254 
00255     sigc::slot3<void, T_arg1,T_arg2,T_arg3> m_slot;
00256 
00257   };
00258 
00261   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00262   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00263     : public MethodBase
00264   {
00265   public:
00266 
00267     typedef DBusCxxPointer<Method> pointer;
00268 
00269     Method(const std::string& name):
00270       MethodBase(name)
00271     {  }
00272 
00273     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00274     {
00275       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message   method=" << m_name );
00276       
00277       if ( not connection or not message ) return NOT_HANDLED;
00278 
00279             
00280       T_arg1 _val_1;
00281       T_arg2 _val_2;
00282       T_arg3 _val_3;
00283       T_arg4 _val_4;
00284 
00285       
00286       try {
00287         Message::iterator i = message->begin();
00288         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00289       }
00290       catch ( ErrorInvalidTypecast& e ) {
00291           return NOT_HANDLED;
00292       }
00293       
00294 
00295       m_slot(_val_1,_val_2,_val_3,_val_4);
00296 
00297       ReturnMessage::const_pointer retmsg;
00298 
00299       if ( message->expects_reply() )
00300       {
00301         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00302         retmsg = message->create_reply();
00303         if ( not retmsg ) return NOT_HANDLED;
00304         connection << retmsg;
00305       }
00306 
00307       return HANDLED;
00308     }
00309 
00310     void set_method( sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00311     { m_slot = slot; }
00312 
00313     static pointer create(const std::string& name)
00314     { return pointer( new Method(name) ); }
00315 
00316     virtual MethodBase::pointer clone()
00317     { return MethodBase::pointer( new Method(this->name()) ); }
00318 
00319   protected:
00320 
00321     sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
00322 
00323   };
00324 
00327   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00328   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00329     : public MethodBase
00330   {
00331   public:
00332 
00333     typedef DBusCxxPointer<Method> pointer;
00334 
00335     Method(const std::string& name):
00336       MethodBase(name)
00337     {  }
00338 
00339     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00340     {
00341       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message   method=" << m_name );
00342       
00343       if ( not connection or not message ) return NOT_HANDLED;
00344 
00345             
00346       T_arg1 _val_1;
00347       T_arg2 _val_2;
00348       T_arg3 _val_3;
00349       T_arg4 _val_4;
00350       T_arg5 _val_5;
00351 
00352       
00353       try {
00354         Message::iterator i = message->begin();
00355         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
00356       }
00357       catch ( ErrorInvalidTypecast& e ) {
00358           return NOT_HANDLED;
00359       }
00360       
00361 
00362       m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
00363 
00364       ReturnMessage::const_pointer retmsg;
00365 
00366       if ( message->expects_reply() )
00367       {
00368         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00369         retmsg = message->create_reply();
00370         if ( not retmsg ) return NOT_HANDLED;
00371         connection << retmsg;
00372       }
00373 
00374       return HANDLED;
00375     }
00376 
00377     void set_method( sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
00378     { m_slot = slot; }
00379 
00380     static pointer create(const std::string& name)
00381     { return pointer( new Method(name) ); }
00382 
00383     virtual MethodBase::pointer clone()
00384     { return MethodBase::pointer( new Method(this->name()) ); }
00385 
00386   protected:
00387 
00388     sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
00389 
00390   };
00391 
00394   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00395   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00396     : public MethodBase
00397   {
00398   public:
00399 
00400     typedef DBusCxxPointer<Method> pointer;
00401 
00402     Method(const std::string& name):
00403       MethodBase(name)
00404     {  }
00405 
00406     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00407     {
00408       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message   method=" << m_name );
00409       
00410       if ( not connection or not message ) return NOT_HANDLED;
00411 
00412             
00413       T_arg1 _val_1;
00414       T_arg2 _val_2;
00415       T_arg3 _val_3;
00416       T_arg4 _val_4;
00417       T_arg5 _val_5;
00418       T_arg6 _val_6;
00419 
00420       
00421       try {
00422         Message::iterator i = message->begin();
00423         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
00424       }
00425       catch ( ErrorInvalidTypecast& e ) {
00426           return NOT_HANDLED;
00427       }
00428       
00429 
00430       m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
00431 
00432       ReturnMessage::const_pointer retmsg;
00433 
00434       if ( message->expects_reply() )
00435       {
00436         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00437         retmsg = message->create_reply();
00438         if ( not retmsg ) return NOT_HANDLED;
00439         connection << retmsg;
00440       }
00441 
00442       return HANDLED;
00443     }
00444 
00445     void set_method( sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
00446     { m_slot = slot; }
00447 
00448     static pointer create(const std::string& name)
00449     { return pointer( new Method(name) ); }
00450 
00451     virtual MethodBase::pointer clone()
00452     { return MethodBase::pointer( new Method(this->name()) ); }
00453 
00454   protected:
00455 
00456     sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
00457 
00458   };
00459 
00460 
00461 
00462 }
00463 
00464 #endif

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