dbus-cxx logo

method_impl.h

Go to the documentation of this file.
00001 
00002 // -*- c++ -*-
00003 /* Do not edit! -- generated file */
00004 
00005 /***************************************************************************
00006  *   Copyright (C) 2009,2010 by Rick L. Vinyard, Jr.                       *
00007  *   rvinyard@cs.nmsu.edu                                                  *
00008  *                                                                         *
00009  *   This file is part of the dbus-cxx library.                            *
00010  *                                                                         *
00011  *   The dbus-cxx library is free software; you can redistribute it and/or *
00012  *   modify it under the terms of the GNU General Public License           *
00013  *   version 3 as published by the Free Software Foundation.               *
00014  *                                                                         *
00015  *   The dbus-cxx library is distributed in the hope that it will be       *
00016  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty   *
00017  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   *
00018  *   General Public License for more details.                              *
00019  *                                                                         *
00020  *   You should have received a copy of the GNU General Public License     *
00021  *   along with this software. If not see <http://www.gnu.org/licenses/>.  *
00022  ***************************************************************************/
00023 #include <dbus-cxx/method.h>
00024 #include <dbus-cxx/connection.h>
00025     
00026 #ifndef DBUSCXX_METHOD_IMPL_H
00027 #define DBUSCXX_METHOD_IMPL_H
00028 
00029 namespace DBus {
00030 
00033   template <>
00034   class Method <void, nil,nil,nil,nil,nil,nil,nil>
00035     : public MethodBase
00036   {
00037   public:
00038 
00039     typedef DBusCxxPointer<Method> pointer;
00040 
00041     Method(const std::string& name):
00042       MethodBase(name)
00043     {  }
00044 
00045     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00046     {
00047       DBUS_CXX_DEBUG("Method<void>::handle_call_message   method=" << m_name );
00048       
00049       if ( not connection or not message ) return NOT_HANDLED;
00050 
00051             
00052 
00053       
00054 
00055       m_slot();
00056 
00057       ReturnMessage::const_pointer retmsg;
00058 
00059       if ( message->expects_reply() )
00060       {
00061         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00062         retmsg = message->create_reply();
00063         if ( not retmsg ) return NOT_HANDLED;
00064         connection << retmsg;
00065       }
00066 
00067       return HANDLED;
00068     }
00069 
00070     void set_method( sigc::slot0<void> 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 
00080     virtual std::string introspect(int space_depth=0) const
00081     {
00082       std::ostringstream sout;
00083       std::string spaces;
00084       for (int i=0; i < space_depth; i++ ) spaces += " ";
00085       sout << spaces << "<method name=\"" << name() << "\">\n";
00086       
00087           sout << spaces << "</method>\n";
00088       return sout.str();
00089     }
00090 
00091     virtual std::string arg_name(size_t i) {
00092       if ( i < 0+1 ) return m_arg_names[i];
00093       return std::string();
00094     }
00095 
00096     virtual void set_arg_name(size_t i, const std::string& name) {
00097       if ( i < 0+1 ) m_arg_names[i] = name;
00098     }
00099 
00100   protected:
00101 
00102     std::string m_arg_names[0+1];
00103 
00104     sigc::slot0<void> m_slot;
00105 
00106   };
00107 
00110   template <class T_arg1>
00111   class Method <void, T_arg1, nil,nil,nil,nil,nil,nil>
00112     : public MethodBase
00113   {
00114   public:
00115 
00116     typedef DBusCxxPointer<Method> pointer;
00117 
00118     Method(const std::string& name):
00119       MethodBase(name)
00120     {  }
00121 
00122     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00123     {
00124       DBUS_CXX_DEBUG("Method<void, T_arg1>::handle_call_message   method=" << m_name );
00125       
00126       if ( not connection or not message ) return NOT_HANDLED;
00127 
00128             
00129       T_arg1 _val_1;
00130 
00131       
00132       try {
00133         Message::iterator i = message->begin();
00134         i  >> _val_1;
00135       }
00136       catch ( ErrorInvalidTypecast& e ) {
00137           return NOT_HANDLED;
00138       }
00139       
00140 
00141       m_slot(_val_1);
00142 
00143       ReturnMessage::const_pointer retmsg;
00144 
00145       if ( message->expects_reply() )
00146       {
00147         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00148         retmsg = message->create_reply();
00149         if ( not retmsg ) return NOT_HANDLED;
00150         connection << retmsg;
00151       }
00152 
00153       return HANDLED;
00154     }
00155 
00156     void set_method( sigc::slot1<void, T_arg1> slot )
00157     { m_slot = slot; }
00158 
00159     static pointer create(const std::string& name)
00160     { return pointer( new Method(name) ); }
00161 
00162     virtual MethodBase::pointer clone()
00163     { return MethodBase::pointer( new Method(this->name()) ); }
00164 
00166     virtual std::string introspect(int space_depth=0) const
00167     {
00168       std::ostringstream sout;
00169       std::string spaces;
00170       for (int i=0; i < space_depth; i++ ) spaces += " ";
00171       sout << spaces << "<method name=\"" << name() << "\">\n";
00172       
00173           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00174           sout << spaces << "</method>\n";
00175       return sout.str();
00176     }
00177 
00178     virtual std::string arg_name(size_t i) {
00179       if ( i < 1+1 ) return m_arg_names[i];
00180       return std::string();
00181     }
00182 
00183     virtual void set_arg_name(size_t i, const std::string& name) {
00184       if ( i < 1+1 ) m_arg_names[i] = name;
00185     }
00186 
00187   protected:
00188 
00189     std::string m_arg_names[1+1];
00190 
00191     sigc::slot1<void, T_arg1> m_slot;
00192 
00193   };
00194 
00197   template <class T_arg1,class T_arg2>
00198   class Method <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00199     : public MethodBase
00200   {
00201   public:
00202 
00203     typedef DBusCxxPointer<Method> pointer;
00204 
00205     Method(const std::string& name):
00206       MethodBase(name)
00207     {  }
00208 
00209     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00210     {
00211       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2>::handle_call_message   method=" << m_name );
00212       
00213       if ( not connection or not message ) return NOT_HANDLED;
00214 
00215             
00216       T_arg1 _val_1;
00217       T_arg2 _val_2;
00218 
00219       
00220       try {
00221         Message::iterator i = message->begin();
00222         i  >> _val_1 >> _val_2;
00223       }
00224       catch ( ErrorInvalidTypecast& e ) {
00225           return NOT_HANDLED;
00226       }
00227       
00228 
00229       m_slot(_val_1,_val_2);
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::slot2<void, T_arg1,T_arg2> 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 
00254     virtual std::string introspect(int space_depth=0) const
00255     {
00256       std::ostringstream sout;
00257       std::string spaces;
00258       for (int i=0; i < space_depth; i++ ) spaces += " ";
00259       sout << spaces << "<method name=\"" << name() << "\">\n";
00260       
00261           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00262           sout << spaces << "  <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00263           sout << spaces << "</method>\n";
00264       return sout.str();
00265     }
00266 
00267     virtual std::string arg_name(size_t i) {
00268       if ( i < 2+1 ) return m_arg_names[i];
00269       return std::string();
00270     }
00271 
00272     virtual void set_arg_name(size_t i, const std::string& name) {
00273       if ( i < 2+1 ) m_arg_names[i] = name;
00274     }
00275 
00276   protected:
00277 
00278     std::string m_arg_names[2+1];
00279 
00280     sigc::slot2<void, T_arg1,T_arg2> m_slot;
00281 
00282   };
00283 
00286   template <class T_arg1,class T_arg2,class T_arg3>
00287   class Method <void, 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<void, 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             
00305       T_arg1 _val_1;
00306       T_arg2 _val_2;
00307       T_arg3 _val_3;
00308 
00309       
00310       try {
00311         Message::iterator i = message->begin();
00312         i  >> _val_1 >> _val_2 >> _val_3;
00313       }
00314       catch ( ErrorInvalidTypecast& e ) {
00315           return NOT_HANDLED;
00316       }
00317       
00318 
00319       m_slot(_val_1,_val_2,_val_3);
00320 
00321       ReturnMessage::const_pointer retmsg;
00322 
00323       if ( message->expects_reply() )
00324       {
00325         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00326         retmsg = message->create_reply();
00327         if ( not retmsg ) return NOT_HANDLED;
00328         connection << retmsg;
00329       }
00330 
00331       return HANDLED;
00332     }
00333 
00334     void set_method( sigc::slot3<void, T_arg1,T_arg2,T_arg3> slot )
00335     { m_slot = slot; }
00336 
00337     static pointer create(const std::string& name)
00338     { return pointer( new Method(name) ); }
00339 
00340     virtual MethodBase::pointer clone()
00341     { return MethodBase::pointer( new Method(this->name()) ); }
00342 
00344     virtual std::string introspect(int space_depth=0) const
00345     {
00346       std::ostringstream sout;
00347       std::string spaces;
00348       for (int i=0; i < space_depth; i++ ) spaces += " ";
00349       sout << spaces << "<method name=\"" << name() << "\">\n";
00350       
00351           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00352           sout << spaces << "  <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00353           sout << spaces << "  <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00354           sout << spaces << "</method>\n";
00355       return sout.str();
00356     }
00357 
00358     virtual std::string arg_name(size_t i) {
00359       if ( i < 3+1 ) return m_arg_names[i];
00360       return std::string();
00361     }
00362 
00363     virtual void set_arg_name(size_t i, const std::string& name) {
00364       if ( i < 3+1 ) m_arg_names[i] = name;
00365     }
00366 
00367   protected:
00368 
00369     std::string m_arg_names[3+1];
00370 
00371     sigc::slot3<void, T_arg1,T_arg2,T_arg3> m_slot;
00372 
00373   };
00374 
00377   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00378   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00379     : public MethodBase
00380   {
00381   public:
00382 
00383     typedef DBusCxxPointer<Method> pointer;
00384 
00385     Method(const std::string& name):
00386       MethodBase(name)
00387     {  }
00388 
00389     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00390     {
00391       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message   method=" << m_name );
00392       
00393       if ( not connection or not message ) return NOT_HANDLED;
00394 
00395             
00396       T_arg1 _val_1;
00397       T_arg2 _val_2;
00398       T_arg3 _val_3;
00399       T_arg4 _val_4;
00400 
00401       
00402       try {
00403         Message::iterator i = message->begin();
00404         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00405       }
00406       catch ( ErrorInvalidTypecast& e ) {
00407           return NOT_HANDLED;
00408       }
00409       
00410 
00411       m_slot(_val_1,_val_2,_val_3,_val_4);
00412 
00413       ReturnMessage::const_pointer retmsg;
00414 
00415       if ( message->expects_reply() )
00416       {
00417         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00418         retmsg = message->create_reply();
00419         if ( not retmsg ) return NOT_HANDLED;
00420         connection << retmsg;
00421       }
00422 
00423       return HANDLED;
00424     }
00425 
00426     void set_method( sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00427     { m_slot = slot; }
00428 
00429     static pointer create(const std::string& name)
00430     { return pointer( new Method(name) ); }
00431 
00432     virtual MethodBase::pointer clone()
00433     { return MethodBase::pointer( new Method(this->name()) ); }
00434 
00436     virtual std::string introspect(int space_depth=0) const
00437     {
00438       std::ostringstream sout;
00439       std::string spaces;
00440       for (int i=0; i < space_depth; i++ ) spaces += " ";
00441       sout << spaces << "<method name=\"" << name() << "\">\n";
00442       
00443           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00444           sout << spaces << "  <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00445           sout << spaces << "  <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00446           sout << spaces << "  <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00447           sout << spaces << "</method>\n";
00448       return sout.str();
00449     }
00450 
00451     virtual std::string arg_name(size_t i) {
00452       if ( i < 4+1 ) return m_arg_names[i];
00453       return std::string();
00454     }
00455 
00456     virtual void set_arg_name(size_t i, const std::string& name) {
00457       if ( i < 4+1 ) m_arg_names[i] = name;
00458     }
00459 
00460   protected:
00461 
00462     std::string m_arg_names[4+1];
00463 
00464     sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
00465 
00466   };
00467 
00470   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00471   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00472     : public MethodBase
00473   {
00474   public:
00475 
00476     typedef DBusCxxPointer<Method> pointer;
00477 
00478     Method(const std::string& name):
00479       MethodBase(name)
00480     {  }
00481 
00482     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00483     {
00484       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message   method=" << m_name );
00485       
00486       if ( not connection or not message ) return NOT_HANDLED;
00487 
00488             
00489       T_arg1 _val_1;
00490       T_arg2 _val_2;
00491       T_arg3 _val_3;
00492       T_arg4 _val_4;
00493       T_arg5 _val_5;
00494 
00495       
00496       try {
00497         Message::iterator i = message->begin();
00498         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
00499       }
00500       catch ( ErrorInvalidTypecast& e ) {
00501           return NOT_HANDLED;
00502       }
00503       
00504 
00505       m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
00506 
00507       ReturnMessage::const_pointer retmsg;
00508 
00509       if ( message->expects_reply() )
00510       {
00511         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00512         retmsg = message->create_reply();
00513         if ( not retmsg ) return NOT_HANDLED;
00514         connection << retmsg;
00515       }
00516 
00517       return HANDLED;
00518     }
00519 
00520     void set_method( sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
00521     { m_slot = slot; }
00522 
00523     static pointer create(const std::string& name)
00524     { return pointer( new Method(name) ); }
00525 
00526     virtual MethodBase::pointer clone()
00527     { return MethodBase::pointer( new Method(this->name()) ); }
00528 
00530     virtual std::string introspect(int space_depth=0) const
00531     {
00532       std::ostringstream sout;
00533       std::string spaces;
00534       for (int i=0; i < space_depth; i++ ) spaces += " ";
00535       sout << spaces << "<method name=\"" << name() << "\">\n";
00536       
00537           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00538           sout << spaces << "  <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00539           sout << spaces << "  <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00540           sout << spaces << "  <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00541           sout << spaces << "  <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
00542           sout << spaces << "</method>\n";
00543       return sout.str();
00544     }
00545 
00546     virtual std::string arg_name(size_t i) {
00547       if ( i < 5+1 ) return m_arg_names[i];
00548       return std::string();
00549     }
00550 
00551     virtual void set_arg_name(size_t i, const std::string& name) {
00552       if ( i < 5+1 ) m_arg_names[i] = name;
00553     }
00554 
00555   protected:
00556 
00557     std::string m_arg_names[5+1];
00558 
00559     sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
00560 
00561   };
00562 
00565   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00566   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00567     : public MethodBase
00568   {
00569   public:
00570 
00571     typedef DBusCxxPointer<Method> pointer;
00572 
00573     Method(const std::string& name):
00574       MethodBase(name)
00575     {  }
00576 
00577     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
00578     {
00579       DBUS_CXX_DEBUG("Method<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message   method=" << m_name );
00580       
00581       if ( not connection or not message ) return NOT_HANDLED;
00582 
00583             
00584       T_arg1 _val_1;
00585       T_arg2 _val_2;
00586       T_arg3 _val_3;
00587       T_arg4 _val_4;
00588       T_arg5 _val_5;
00589       T_arg6 _val_6;
00590 
00591       
00592       try {
00593         Message::iterator i = message->begin();
00594         i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
00595       }
00596       catch ( ErrorInvalidTypecast& e ) {
00597           return NOT_HANDLED;
00598       }
00599       
00600 
00601       m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
00602 
00603       ReturnMessage::const_pointer retmsg;
00604 
00605       if ( message->expects_reply() )
00606       {
00607         DBUS_CXX_DEBUG( "REPLY EXPECTED" );
00608         retmsg = message->create_reply();
00609         if ( not retmsg ) return NOT_HANDLED;
00610         connection << retmsg;
00611       }
00612 
00613       return HANDLED;
00614     }
00615 
00616     void set_method( sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
00617     { m_slot = slot; }
00618 
00619     static pointer create(const std::string& name)
00620     { return pointer( new Method(name) ); }
00621 
00622     virtual MethodBase::pointer clone()
00623     { return MethodBase::pointer( new Method(this->name()) ); }
00624 
00626     virtual std::string introspect(int space_depth=0) const
00627     {
00628       std::ostringstream sout;
00629       std::string spaces;
00630       for (int i=0; i < space_depth; i++ ) spaces += " ";
00631       sout << spaces << "<method name=\"" << name() << "\">\n";
00632       
00633           sout << spaces << "  <arg name=\"" << m_arg_names[1] << "\" type=\"" << signature<T_arg1>() << "\" direction=\"in\"/>\n";
00634           sout << spaces << "  <arg name=\"" << m_arg_names[2] << "\" type=\"" << signature<T_arg2>() << "\" direction=\"in\"/>\n";
00635           sout << spaces << "  <arg name=\"" << m_arg_names[3] << "\" type=\"" << signature<T_arg3>() << "\" direction=\"in\"/>\n";
00636           sout << spaces << "  <arg name=\"" << m_arg_names[4] << "\" type=\"" << signature<T_arg4>() << "\" direction=\"in\"/>\n";
00637           sout << spaces << "  <arg name=\"" << m_arg_names[5] << "\" type=\"" << signature<T_arg5>() << "\" direction=\"in\"/>\n";
00638           sout << spaces << "  <arg name=\"" << m_arg_names[6] << "\" type=\"" << signature<T_arg6>() << "\" direction=\"in\"/>\n";
00639           sout << spaces << "</method>\n";
00640       return sout.str();
00641     }
00642 
00643     virtual std::string arg_name(size_t i) {
00644       if ( i < 6+1 ) return m_arg_names[i];
00645       return std::string();
00646     }
00647 
00648     virtual void set_arg_name(size_t i, const std::string& name) {
00649       if ( i < 6+1 ) m_arg_names[i] = name;
00650     }
00651 
00652   protected:
00653 
00654     std::string m_arg_names[6+1];
00655 
00656     sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
00657 
00658   };
00659 
00660 
00661 
00662 }
00663 
00664 #endif

Generated on Thu Mar 18 09:30:54 2010 for dbus-cxx by doxygen 1.6.1