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 
00062     virtual std::string introspect(int space_depth=0) const
00063     {
00064       std::ostringstream sout;
00065       std::string spaces;
00066       for (int i=0; i < space_depth; i++ ) spaces += " ";
00067       sout << spaces << "<method name=\"" << name() << "\">\n";
00068       
00069           sout << spaces << "</method>\n";
00070       return sout.str();
00071     }
00072 
00073     virtual std::string arg_name(size_t i) {
00074       if ( i < 0+1 ) return m_arg_names[i];
00075       return std::string();
00076     }
00077 
00078     virtual void set_arg_name(size_t i, const std::string& name) {
00079       if ( i < 0+1 ) m_arg_names[i] = name;
00080     }
00081 
00082   protected:
00083 
00084     std::string m_arg_names[0+1];
00085 
00086     sigc::slot0<void> m_slot;
00087 
00088   };
00089 
00092   template <class T_arg1>
00093   class Method <void, T_arg1, nil,nil,nil,nil,nil,nil>
00094     : public MethodBase
00095   {
00096   public:
00097 
00098     typedef DBusCxxPointer<Method> pointer;
00099 
00100     Method(const std::string& name):
00101       MethodBase(name)
00102     {  }
00103 
00104     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00105     {
00106       DBUS_CXX_DEBUG("Method<void, T_arg1>::handle_call_message   method=" << m_name );
00107       
00108       if ( not connection or not message ) return NOT_HANDLED;
00109 
00110             
00111       T_arg1 _val_1;
00112 
00113       
00114       try {
00115         Message::iterator i = message->begin();
00116         i  >> _val_1;
00117       }
00118       catch ( ErrorInvalidTypecast& e ) {
00119           return NOT_HANDLED;
00120       }
00121       
00122 
00123       m_slot(_val_1);
00124 
00125       ReturnMessage::const_pointer retmsg;
00126 
00127       if ( message->expects_reply() )
00128       {
00129         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00130         retmsg = message->create_reply();
00131         if ( not retmsg ) return NOT_HANDLED;
00132         connection << retmsg;
00133       }
00134 
00135       return HANDLED;
00136     }
00137 
00138     void set_method( sigc::slot1<void, T_arg1> slot )
00139     { m_slot = slot; }
00140 
00141     static pointer create(const std::string& name)
00142     { return pointer( new Method(name) ); }
00143 
00144     virtual MethodBase::pointer clone()
00145     { return MethodBase::pointer( new Method(this->name()) ); }
00146 
00148     virtual std::string introspect(int space_depth=0) const
00149     {
00150       std::ostringstream sout;
00151       std::string spaces;
00152       for (int i=0; i < space_depth; i++ ) spaces += " ";
00153       sout << spaces << "<method name=\"" << name() << "\">\n";
00154       
00155           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00156           sout << spaces << "</method>\n";
00157       return sout.str();
00158     }
00159 
00160     virtual std::string arg_name(size_t i) {
00161       if ( i < 1+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 < 1+1 ) m_arg_names[i] = name;
00167     }
00168 
00169   protected:
00170 
00171     std::string m_arg_names[1+1];
00172 
00173     sigc::slot1<void, T_arg1> m_slot;
00174 
00175   };
00176 
00179   template <class T_arg1,class T_arg2>
00180   class Method <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00181     : public MethodBase
00182   {
00183   public:
00184 
00185     typedef DBusCxxPointer<Method> pointer;
00186 
00187     Method(const std::string& name):
00188       MethodBase(name)
00189     {  }
00190 
00191     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00192     {
00193       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2>::handle_call_message   method=" << m_name );
00194       
00195       if ( not connection or not message ) return NOT_HANDLED;
00196 
00197             
00198       T_arg1 _val_1;
00199       T_arg2 _val_2;
00200 
00201       
00202       try {
00203         Message::iterator i = message->begin();
00204         i  >> _val_1 >> _val_2;
00205       }
00206       catch ( ErrorInvalidTypecast& e ) {
00207           return NOT_HANDLED;
00208       }
00209       
00210 
00211       m_slot(_val_1,_val_2);
00212 
00213       ReturnMessage::const_pointer retmsg;
00214 
00215       if ( message->expects_reply() )
00216       {
00217         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00218         retmsg = message->create_reply();
00219         if ( not retmsg ) return NOT_HANDLED;
00220         connection << retmsg;
00221       }
00222 
00223       return HANDLED;
00224     }
00225 
00226     void set_method( sigc::slot2<void, T_arg1,T_arg2> slot )
00227     { m_slot = slot; }
00228 
00229     static pointer create(const std::string& name)
00230     { return pointer( new Method(name) ); }
00231 
00232     virtual MethodBase::pointer clone()
00233     { return MethodBase::pointer( new Method(this->name()) ); }
00234 
00236     virtual std::string introspect(int space_depth=0) const
00237     {
00238       std::ostringstream sout;
00239       std::string spaces;
00240       for (int i=0; i < space_depth; i++ ) spaces += " ";
00241       sout << spaces << "<method name=\"" << name() << "\">\n";
00242       
00243           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00244           sout << spaces << "  <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00245           sout << spaces << "</method>\n";
00246       return sout.str();
00247     }
00248 
00249     virtual std::string arg_name(size_t i) {
00250       if ( i < 2+1 ) return m_arg_names[i];
00251       return std::string();
00252     }
00253 
00254     virtual void set_arg_name(size_t i, const std::string& name) {
00255       if ( i < 2+1 ) m_arg_names[i] = name;
00256     }
00257 
00258   protected:
00259 
00260     std::string m_arg_names[2+1];
00261 
00262     sigc::slot2<void, T_arg1,T_arg2> m_slot;
00263 
00264   };
00265 
00268   template <class T_arg1,class T_arg2,class T_arg3>
00269   class Method <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00270     : public MethodBase
00271   {
00272   public:
00273 
00274     typedef DBusCxxPointer<Method> pointer;
00275 
00276     Method(const std::string& name):
00277       MethodBase(name)
00278     {  }
00279 
00280     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00281     {
00282       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3>::handle_call_message   method=" << m_name );
00283       
00284       if ( not connection or not message ) return NOT_HANDLED;
00285 
00286             
00287       T_arg1 _val_1;
00288       T_arg2 _val_2;
00289       T_arg3 _val_3;
00290 
00291       
00292       try {
00293         Message::iterator i = message->begin();
00294         i  >> _val_1 >> _val_2 >> _val_3;
00295       }
00296       catch ( ErrorInvalidTypecast& e ) {
00297           return NOT_HANDLED;
00298       }
00299       
00300 
00301       m_slot(_val_1,_val_2,_val_3);
00302 
00303       ReturnMessage::const_pointer retmsg;
00304 
00305       if ( message->expects_reply() )
00306       {
00307         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00308         retmsg = message->create_reply();
00309         if ( not retmsg ) return NOT_HANDLED;
00310         connection << retmsg;
00311       }
00312 
00313       return HANDLED;
00314     }
00315 
00316     void set_method( sigc::slot3<void, T_arg1,T_arg2,T_arg3> slot )
00317     { m_slot = slot; }
00318 
00319     static pointer create(const std::string& name)
00320     { return pointer( new Method(name) ); }
00321 
00322     virtual MethodBase::pointer clone()
00323     { return MethodBase::pointer( new Method(this->name()) ); }
00324 
00326     virtual std::string introspect(int space_depth=0) const
00327     {
00328       std::ostringstream sout;
00329       std::string spaces;
00330       for (int i=0; i < space_depth; i++ ) spaces += " ";
00331       sout << spaces << "<method name=\"" << name() << "\">\n";
00332       
00333           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00334           sout << spaces << "  <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00335           sout << spaces << "  <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00336           sout << spaces << "</method>\n";
00337       return sout.str();
00338     }
00339 
00340     virtual std::string arg_name(size_t i) {
00341       if ( i < 3+1 ) return m_arg_names[i];
00342       return std::string();
00343     }
00344 
00345     virtual void set_arg_name(size_t i, const std::string& name) {
00346       if ( i < 3+1 ) m_arg_names[i] = name;
00347     }
00348 
00349   protected:
00350 
00351     std::string m_arg_names[3+1];
00352 
00353     sigc::slot3<void, T_arg1,T_arg2,T_arg3> m_slot;
00354 
00355   };
00356 
00359   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00360   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00361     : public MethodBase
00362   {
00363   public:
00364 
00365     typedef DBusCxxPointer<Method> pointer;
00366 
00367     Method(const std::string& name):
00368       MethodBase(name)
00369     {  }
00370 
00371     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00372     {
00373       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message   method=" << m_name );
00374       
00375       if ( not connection or not message ) return NOT_HANDLED;
00376 
00377             
00378       T_arg1 _val_1;
00379       T_arg2 _val_2;
00380       T_arg3 _val_3;
00381       T_arg4 _val_4;
00382 
00383       
00384       try {
00385         Message::iterator i = message->begin();
00386         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00387       }
00388       catch ( ErrorInvalidTypecast& e ) {
00389           return NOT_HANDLED;
00390       }
00391       
00392 
00393       m_slot(_val_1,_val_2,_val_3,_val_4);
00394 
00395       ReturnMessage::const_pointer retmsg;
00396 
00397       if ( message->expects_reply() )
00398       {
00399         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00400         retmsg = message->create_reply();
00401         if ( not retmsg ) return NOT_HANDLED;
00402         connection << retmsg;
00403       }
00404 
00405       return HANDLED;
00406     }
00407 
00408     void set_method( sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00409     { m_slot = slot; }
00410 
00411     static pointer create(const std::string& name)
00412     { return pointer( new Method(name) ); }
00413 
00414     virtual MethodBase::pointer clone()
00415     { return MethodBase::pointer( new Method(this->name()) ); }
00416 
00418     virtual std::string introspect(int space_depth=0) const
00419     {
00420       std::ostringstream sout;
00421       std::string spaces;
00422       for (int i=0; i < space_depth; i++ ) spaces += " ";
00423       sout << spaces << "<method name=\"" << name() << "\">\n";
00424       
00425           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00426           sout << spaces << "  <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00427           sout << spaces << "  <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00428           sout << spaces << "  <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00429           sout << spaces << "</method>\n";
00430       return sout.str();
00431     }
00432 
00433     virtual std::string arg_name(size_t i) {
00434       if ( i < 4+1 ) return m_arg_names[i];
00435       return std::string();
00436     }
00437 
00438     virtual void set_arg_name(size_t i, const std::string& name) {
00439       if ( i < 4+1 ) m_arg_names[i] = name;
00440     }
00441 
00442   protected:
00443 
00444     std::string m_arg_names[4+1];
00445 
00446     sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
00447 
00448   };
00449 
00452   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00453   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00454     : public MethodBase
00455   {
00456   public:
00457 
00458     typedef DBusCxxPointer<Method> pointer;
00459 
00460     Method(const std::string& name):
00461       MethodBase(name)
00462     {  }
00463 
00464     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00465     {
00466       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message   method=" << m_name );
00467       
00468       if ( not connection or not message ) return NOT_HANDLED;
00469 
00470             
00471       T_arg1 _val_1;
00472       T_arg2 _val_2;
00473       T_arg3 _val_3;
00474       T_arg4 _val_4;
00475       T_arg5 _val_5;
00476 
00477       
00478       try {
00479         Message::iterator i = message->begin();
00480         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
00481       }
00482       catch ( ErrorInvalidTypecast& e ) {
00483           return NOT_HANDLED;
00484       }
00485       
00486 
00487       m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
00488 
00489       ReturnMessage::const_pointer retmsg;
00490 
00491       if ( message->expects_reply() )
00492       {
00493         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00494         retmsg = message->create_reply();
00495         if ( not retmsg ) return NOT_HANDLED;
00496         connection << retmsg;
00497       }
00498 
00499       return HANDLED;
00500     }
00501 
00502     void set_method( sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
00503     { m_slot = slot; }
00504 
00505     static pointer create(const std::string& name)
00506     { return pointer( new Method(name) ); }
00507 
00508     virtual MethodBase::pointer clone()
00509     { return MethodBase::pointer( new Method(this->name()) ); }
00510 
00512     virtual std::string introspect(int space_depth=0) const
00513     {
00514       std::ostringstream sout;
00515       std::string spaces;
00516       for (int i=0; i < space_depth; i++ ) spaces += " ";
00517       sout << spaces << "<method name=\"" << name() << "\">\n";
00518       
00519           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00520           sout << spaces << "  <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00521           sout << spaces << "  <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00522           sout << spaces << "  <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00523           sout << spaces << "  <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
00524           sout << spaces << "</method>\n";
00525       return sout.str();
00526     }
00527 
00528     virtual std::string arg_name(size_t i) {
00529       if ( i < 5+1 ) return m_arg_names[i];
00530       return std::string();
00531     }
00532 
00533     virtual void set_arg_name(size_t i, const std::string& name) {
00534       if ( i < 5+1 ) m_arg_names[i] = name;
00535     }
00536 
00537   protected:
00538 
00539     std::string m_arg_names[5+1];
00540 
00541     sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
00542 
00543   };
00544 
00547   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00548   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00549     : public MethodBase
00550   {
00551   public:
00552 
00553     typedef DBusCxxPointer<Method> pointer;
00554 
00555     Method(const std::string& name):
00556       MethodBase(name)
00557     {  }
00558 
00559     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00560     {
00561       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message   method=" << m_name );
00562       
00563       if ( not connection or not message ) return NOT_HANDLED;
00564 
00565             
00566       T_arg1 _val_1;
00567       T_arg2 _val_2;
00568       T_arg3 _val_3;
00569       T_arg4 _val_4;
00570       T_arg5 _val_5;
00571       T_arg6 _val_6;
00572 
00573       
00574       try {
00575         Message::iterator i = message->begin();
00576         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
00577       }
00578       catch ( ErrorInvalidTypecast& e ) {
00579           return NOT_HANDLED;
00580       }
00581       
00582 
00583       m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
00584 
00585       ReturnMessage::const_pointer retmsg;
00586 
00587       if ( message->expects_reply() )
00588       {
00589         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00590         retmsg = message->create_reply();
00591         if ( not retmsg ) return NOT_HANDLED;
00592         connection << retmsg;
00593       }
00594 
00595       return HANDLED;
00596     }
00597 
00598     void set_method( sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
00599     { m_slot = slot; }
00600 
00601     static pointer create(const std::string& name)
00602     { return pointer( new Method(name) ); }
00603 
00604     virtual MethodBase::pointer clone()
00605     { return MethodBase::pointer( new Method(this->name()) ); }
00606 
00608     virtual std::string introspect(int space_depth=0) const
00609     {
00610       std::ostringstream sout;
00611       std::string spaces;
00612       for (int i=0; i < space_depth; i++ ) spaces += " ";
00613       sout << spaces << "<method name=\"" << name() << "\">\n";
00614       
00615           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00616           sout << spaces << "  <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00617           sout << spaces << "  <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00618           sout << spaces << "  <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00619           sout << spaces << "  <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
00620           sout << spaces << "  <arg name=\"" << m_arg_names[6] << "\" type=\"" << signature<T_arg6>() << "\" direction=\"in\"/>\n";
00621           sout << spaces << "</method>\n";
00622       return sout.str();
00623     }
00624 
00625     virtual std::string arg_name(size_t i) {
00626       if ( i < 6+1 ) return m_arg_names[i];
00627       return std::string();
00628     }
00629 
00630     virtual void set_arg_name(size_t i, const std::string& name) {
00631       if ( i < 6+1 ) m_arg_names[i] = name;
00632     }
00633 
00634   protected:
00635 
00636     std::string m_arg_names[6+1];
00637 
00638     sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
00639 
00640   };
00641 
00642 
00643 
00644 }
00645 
00646 #endif

Generated on Fri Jun 26 15:50:37 2009 for dbus-cxx by doxygen 1.5.8