dbus-cxx logo

method.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 <sstream>
00024 #include <dbus-cxx/forward_decls.h>
00025 #include <dbus-cxx/methodbase.h>
00026 #include <dbus-cxx/utility.h>
00027     
00028 #ifndef DBUSCXX_METHOD_H
00029 #define DBUSCXX_METHOD_H
00030 
00031 namespace DBus {
00032 
00039   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
00040   class Method 
00041     : public MethodBase
00042   {
00043   public:
00044 
00045     typedef DBusCxxPointer<Method> pointer;
00046 
00047     Method(const std::string& name): MethodBase(name) {  }
00048     
00049     virtual ~Method() { }
00050 
00051     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00052                                                CallMessage::const_pointer message );
00053 
00054     void set_method( sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot )
00055     { m_slot = slot; }
00056 
00057     static pointer create(const std::string& name)
00058     { return pointer( new Method(name) ); }
00059 
00060     virtual MethodBase::pointer clone()
00061     { return MethodBase::pointer( new Method(this->name()) ); }
00062 
00064     virtual std::string introspect(int space_depth=0) const
00065     {
00066       std::ostringstream sout;
00067       std::string spaces;
00068       for (int i=0; i < space_depth; i++ ) spaces += " ";
00069       sout << spaces << "<method name=\"" << name() << "\">\n";
00070       sout << spaces << "  <arg name=\"" << m_arg_names[0]
00071            << "\" type=\"" << signature<T_return>()
00072            << "\" direction=\"out\"/>\n";
00073       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00074            << "\" type=\"" << signature<T_arg1>()
00075            << "\" direction=\"in\"/>\n";
00076       sout << spaces << "  <arg name=\"" << m_arg_names[2]
00077            << "\" type=\"" << signature<T_arg2>()
00078            << "\" direction=\"in\"/>\n";
00079       sout << spaces << "  <arg name=\"" << m_arg_names[3]
00080            << "\" type=\"" << signature<T_arg3>()
00081            << "\" direction=\"in\"/>\n";
00082       sout << spaces << "  <arg name=\"" << m_arg_names[4]
00083            << "\" type=\"" << signature<T_arg4>()
00084            << "\" direction=\"in\"/>\n";
00085       sout << spaces << "  <arg name=\"" << m_arg_names[5]
00086            << "\" type=\"" << signature<T_arg5>()
00087            << "\" direction=\"in\"/>\n";
00088       sout << spaces << "  <arg name=\"" << m_arg_names[6]
00089            << "\" type=\"" << signature<T_arg6>()
00090            << "\" direction=\"in\"/>\n";
00091       sout << spaces << "  <arg name=\"" << m_arg_names[7]
00092            << "\" type=\"" << signature<T_arg7>()
00093            << "\" direction=\"in\"/>\n";
00094       sout << spaces << "</method>\n";
00095       return sout.str();
00096     }
00097 
00098     virtual std::string arg_name(size_t i) {
00099       if ( i < 7+1 ) return m_arg_names[i];
00100       return std::string();
00101     }
00102 
00103     virtual void set_arg_name(size_t i, const std::string& name) {
00104       if ( i < 7+1 ) m_arg_names[i] = name;
00105     }
00106 
00107   protected:
00108 
00109     std::string m_arg_names[7+1];
00110 
00111     sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> m_slot;
00112 
00113   };
00114 
00115 
00122   template <class T_return>
00123   class Method <T_return, nil,nil,nil,nil,nil,nil,nil>
00124     : public MethodBase
00125   {
00126   public:
00127 
00128     typedef DBusCxxPointer<Method> pointer;
00129 
00130     Method(const std::string& name): MethodBase(name) {  }
00131     
00132     virtual ~Method() { }
00133 
00134     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00135                                                CallMessage::const_pointer message );
00136 
00137     void set_method( sigc::slot0<T_return> slot )
00138     { m_slot = slot; }
00139 
00140     static pointer create(const std::string& name)
00141     { return pointer( new Method(name) ); }
00142 
00143     virtual MethodBase::pointer clone()
00144     { return MethodBase::pointer( new Method(this->name()) ); }
00145 
00147     virtual std::string introspect(int space_depth=0) const
00148     {
00149       std::ostringstream sout;
00150       std::string spaces;
00151       for (int i=0; i < space_depth; i++ ) spaces += " ";
00152       sout << spaces << "<method name=\"" << name() << "\">\n";
00153       sout << spaces << "  <arg name=\"" << m_arg_names[0]
00154            << "\" type=\"" << signature<T_return>()
00155            << "\" direction=\"out\"/>\n";
00156       sout << spaces << "</method>\n";
00157       return sout.str();
00158     }
00159 
00160     virtual std::string arg_name(size_t i) {
00161       if ( i < 0+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 < 0+1 ) m_arg_names[i] = name;
00167     }
00168 
00169   protected:
00170 
00171     std::string m_arg_names[0+1];
00172 
00173     sigc::slot0<T_return> m_slot;
00174 
00175   };
00176 
00183   template <class T_return, class T_arg1>
00184   class Method <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00185     : public MethodBase
00186   {
00187   public:
00188 
00189     typedef DBusCxxPointer<Method> pointer;
00190 
00191     Method(const std::string& name): MethodBase(name) {  }
00192     
00193     virtual ~Method() { }
00194 
00195     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00196                                                CallMessage::const_pointer message );
00197 
00198     void set_method( sigc::slot1<T_return, T_arg1> slot )
00199     { m_slot = slot; }
00200 
00201     static pointer create(const std::string& name)
00202     { return pointer( new Method(name) ); }
00203 
00204     virtual MethodBase::pointer clone()
00205     { return MethodBase::pointer( new Method(this->name()) ); }
00206 
00208     virtual std::string introspect(int space_depth=0) const
00209     {
00210       std::ostringstream sout;
00211       std::string spaces;
00212       for (int i=0; i < space_depth; i++ ) spaces += " ";
00213       sout << spaces << "<method name=\"" << name() << "\">\n";
00214       sout << spaces << "  <arg name=\"" << m_arg_names[0]
00215            << "\" type=\"" << signature<T_return>()
00216            << "\" direction=\"out\"/>\n";
00217       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00218            << "\" type=\"" << signature<T_arg1>()
00219            << "\" direction=\"in\"/>\n";
00220       sout << spaces << "</method>\n";
00221       return sout.str();
00222     }
00223 
00224     virtual std::string arg_name(size_t i) {
00225       if ( i < 1+1 ) return m_arg_names[i];
00226       return std::string();
00227     }
00228 
00229     virtual void set_arg_name(size_t i, const std::string& name) {
00230       if ( i < 1+1 ) m_arg_names[i] = name;
00231     }
00232 
00233   protected:
00234 
00235     std::string m_arg_names[1+1];
00236 
00237     sigc::slot1<T_return, T_arg1> m_slot;
00238 
00239   };
00240 
00247   template <class T_return, class T_arg1,class T_arg2>
00248   class Method <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00249     : public MethodBase
00250   {
00251   public:
00252 
00253     typedef DBusCxxPointer<Method> pointer;
00254 
00255     Method(const std::string& name): MethodBase(name) {  }
00256     
00257     virtual ~Method() { }
00258 
00259     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00260                                                CallMessage::const_pointer message );
00261 
00262     void set_method( sigc::slot2<T_return, T_arg1,T_arg2> slot )
00263     { m_slot = slot; }
00264 
00265     static pointer create(const std::string& name)
00266     { return pointer( new Method(name) ); }
00267 
00268     virtual MethodBase::pointer clone()
00269     { return MethodBase::pointer( new Method(this->name()) ); }
00270 
00272     virtual std::string introspect(int space_depth=0) const
00273     {
00274       std::ostringstream sout;
00275       std::string spaces;
00276       for (int i=0; i < space_depth; i++ ) spaces += " ";
00277       sout << spaces << "<method name=\"" << name() << "\">\n";
00278       sout << spaces << "  <arg name=\"" << m_arg_names[0]
00279            << "\" type=\"" << signature<T_return>()
00280            << "\" direction=\"out\"/>\n";
00281       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00282            << "\" type=\"" << signature<T_arg1>()
00283            << "\" direction=\"in\"/>\n";
00284       sout << spaces << "  <arg name=\"" << m_arg_names[2]
00285            << "\" type=\"" << signature<T_arg2>()
00286            << "\" direction=\"in\"/>\n";
00287       sout << spaces << "</method>\n";
00288       return sout.str();
00289     }
00290 
00291     virtual std::string arg_name(size_t i) {
00292       if ( i < 2+1 ) return m_arg_names[i];
00293       return std::string();
00294     }
00295 
00296     virtual void set_arg_name(size_t i, const std::string& name) {
00297       if ( i < 2+1 ) m_arg_names[i] = name;
00298     }
00299 
00300   protected:
00301 
00302     std::string m_arg_names[2+1];
00303 
00304     sigc::slot2<T_return, T_arg1,T_arg2> m_slot;
00305 
00306   };
00307 
00314   template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00315   class Method <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00316     : public MethodBase
00317   {
00318   public:
00319 
00320     typedef DBusCxxPointer<Method> pointer;
00321 
00322     Method(const std::string& name): MethodBase(name) {  }
00323     
00324     virtual ~Method() { }
00325 
00326     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00327                                                CallMessage::const_pointer message );
00328 
00329     void set_method( sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> slot )
00330     { m_slot = slot; }
00331 
00332     static pointer create(const std::string& name)
00333     { return pointer( new Method(name) ); }
00334 
00335     virtual MethodBase::pointer clone()
00336     { return MethodBase::pointer( new Method(this->name()) ); }
00337 
00339     virtual std::string introspect(int space_depth=0) const
00340     {
00341       std::ostringstream sout;
00342       std::string spaces;
00343       for (int i=0; i < space_depth; i++ ) spaces += " ";
00344       sout << spaces << "<method name=\"" << name() << "\">\n";
00345       sout << spaces << "  <arg name=\"" << m_arg_names[0]
00346            << "\" type=\"" << signature<T_return>()
00347            << "\" direction=\"out\"/>\n";
00348       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00349            << "\" type=\"" << signature<T_arg1>()
00350            << "\" direction=\"in\"/>\n";
00351       sout << spaces << "  <arg name=\"" << m_arg_names[2]
00352            << "\" type=\"" << signature<T_arg2>()
00353            << "\" direction=\"in\"/>\n";
00354       sout << spaces << "  <arg name=\"" << m_arg_names[3]
00355            << "\" type=\"" << signature<T_arg3>()
00356            << "\" direction=\"in\"/>\n";
00357       sout << spaces << "</method>\n";
00358       return sout.str();
00359     }
00360 
00361     virtual std::string arg_name(size_t i) {
00362       if ( i < 3+1 ) return m_arg_names[i];
00363       return std::string();
00364     }
00365 
00366     virtual void set_arg_name(size_t i, const std::string& name) {
00367       if ( i < 3+1 ) m_arg_names[i] = name;
00368     }
00369 
00370   protected:
00371 
00372     std::string m_arg_names[3+1];
00373 
00374     sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> m_slot;
00375 
00376   };
00377 
00384   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00385   class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00386     : public MethodBase
00387   {
00388   public:
00389 
00390     typedef DBusCxxPointer<Method> pointer;
00391 
00392     Method(const std::string& name): MethodBase(name) {  }
00393     
00394     virtual ~Method() { }
00395 
00396     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00397                                                CallMessage::const_pointer message );
00398 
00399     void set_method( sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00400     { m_slot = slot; }
00401 
00402     static pointer create(const std::string& name)
00403     { return pointer( new Method(name) ); }
00404 
00405     virtual MethodBase::pointer clone()
00406     { return MethodBase::pointer( new Method(this->name()) ); }
00407 
00409     virtual std::string introspect(int space_depth=0) const
00410     {
00411       std::ostringstream sout;
00412       std::string spaces;
00413       for (int i=0; i < space_depth; i++ ) spaces += " ";
00414       sout << spaces << "<method name=\"" << name() << "\">\n";
00415       sout << spaces << "  <arg name=\"" << m_arg_names[0]
00416            << "\" type=\"" << signature<T_return>()
00417            << "\" direction=\"out\"/>\n";
00418       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00419            << "\" type=\"" << signature<T_arg1>()
00420            << "\" direction=\"in\"/>\n";
00421       sout << spaces << "  <arg name=\"" << m_arg_names[2]
00422            << "\" type=\"" << signature<T_arg2>()
00423            << "\" direction=\"in\"/>\n";
00424       sout << spaces << "  <arg name=\"" << m_arg_names[3]
00425            << "\" type=\"" << signature<T_arg3>()
00426            << "\" direction=\"in\"/>\n";
00427       sout << spaces << "  <arg name=\"" << m_arg_names[4]
00428            << "\" type=\"" << signature<T_arg4>()
00429            << "\" direction=\"in\"/>\n";
00430       sout << spaces << "</method>\n";
00431       return sout.str();
00432     }
00433 
00434     virtual std::string arg_name(size_t i) {
00435       if ( i < 4+1 ) return m_arg_names[i];
00436       return std::string();
00437     }
00438 
00439     virtual void set_arg_name(size_t i, const std::string& name) {
00440       if ( i < 4+1 ) m_arg_names[i] = name;
00441     }
00442 
00443   protected:
00444 
00445     std::string m_arg_names[4+1];
00446 
00447     sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
00448 
00449   };
00450 
00457   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00458   class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00459     : public MethodBase
00460   {
00461   public:
00462 
00463     typedef DBusCxxPointer<Method> pointer;
00464 
00465     Method(const std::string& name): MethodBase(name) {  }
00466     
00467     virtual ~Method() { }
00468 
00469     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00470                                                CallMessage::const_pointer message );
00471 
00472     void set_method( sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
00473     { m_slot = slot; }
00474 
00475     static pointer create(const std::string& name)
00476     { return pointer( new Method(name) ); }
00477 
00478     virtual MethodBase::pointer clone()
00479     { return MethodBase::pointer( new Method(this->name()) ); }
00480 
00482     virtual std::string introspect(int space_depth=0) const
00483     {
00484       std::ostringstream sout;
00485       std::string spaces;
00486       for (int i=0; i < space_depth; i++ ) spaces += " ";
00487       sout << spaces << "<method name=\"" << name() << "\">\n";
00488       sout << spaces << "  <arg name=\"" << m_arg_names[0]
00489            << "\" type=\"" << signature<T_return>()
00490            << "\" direction=\"out\"/>\n";
00491       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00492            << "\" type=\"" << signature<T_arg1>()
00493            << "\" direction=\"in\"/>\n";
00494       sout << spaces << "  <arg name=\"" << m_arg_names[2]
00495            << "\" type=\"" << signature<T_arg2>()
00496            << "\" direction=\"in\"/>\n";
00497       sout << spaces << "  <arg name=\"" << m_arg_names[3]
00498            << "\" type=\"" << signature<T_arg3>()
00499            << "\" direction=\"in\"/>\n";
00500       sout << spaces << "  <arg name=\"" << m_arg_names[4]
00501            << "\" type=\"" << signature<T_arg4>()
00502            << "\" direction=\"in\"/>\n";
00503       sout << spaces << "  <arg name=\"" << m_arg_names[5]
00504            << "\" type=\"" << signature<T_arg5>()
00505            << "\" direction=\"in\"/>\n";
00506       sout << spaces << "</method>\n";
00507       return sout.str();
00508     }
00509 
00510     virtual std::string arg_name(size_t i) {
00511       if ( i < 5+1 ) return m_arg_names[i];
00512       return std::string();
00513     }
00514 
00515     virtual void set_arg_name(size_t i, const std::string& name) {
00516       if ( i < 5+1 ) m_arg_names[i] = name;
00517     }
00518 
00519   protected:
00520 
00521     std::string m_arg_names[5+1];
00522 
00523     sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
00524 
00525   };
00526 
00533   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00534   class Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00535     : public MethodBase
00536   {
00537   public:
00538 
00539     typedef DBusCxxPointer<Method> pointer;
00540 
00541     Method(const std::string& name): MethodBase(name) {  }
00542     
00543     virtual ~Method() { }
00544 
00545     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00546                                                CallMessage::const_pointer message );
00547 
00548     void set_method( sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
00549     { m_slot = slot; }
00550 
00551     static pointer create(const std::string& name)
00552     { return pointer( new Method(name) ); }
00553 
00554     virtual MethodBase::pointer clone()
00555     { return MethodBase::pointer( new Method(this->name()) ); }
00556 
00558     virtual std::string introspect(int space_depth=0) const
00559     {
00560       std::ostringstream sout;
00561       std::string spaces;
00562       for (int i=0; i < space_depth; i++ ) spaces += " ";
00563       sout << spaces << "<method name=\"" << name() << "\">\n";
00564       sout << spaces << "  <arg name=\"" << m_arg_names[0]
00565            << "\" type=\"" << signature<T_return>()
00566            << "\" direction=\"out\"/>\n";
00567       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00568            << "\" type=\"" << signature<T_arg1>()
00569            << "\" direction=\"in\"/>\n";
00570       sout << spaces << "  <arg name=\"" << m_arg_names[2]
00571            << "\" type=\"" << signature<T_arg2>()
00572            << "\" direction=\"in\"/>\n";
00573       sout << spaces << "  <arg name=\"" << m_arg_names[3]
00574            << "\" type=\"" << signature<T_arg3>()
00575            << "\" direction=\"in\"/>\n";
00576       sout << spaces << "  <arg name=\"" << m_arg_names[4]
00577            << "\" type=\"" << signature<T_arg4>()
00578            << "\" direction=\"in\"/>\n";
00579       sout << spaces << "  <arg name=\"" << m_arg_names[5]
00580            << "\" type=\"" << signature<T_arg5>()
00581            << "\" direction=\"in\"/>\n";
00582       sout << spaces << "  <arg name=\"" << m_arg_names[6]
00583            << "\" type=\"" << signature<T_arg6>()
00584            << "\" direction=\"in\"/>\n";
00585       sout << spaces << "</method>\n";
00586       return sout.str();
00587     }
00588 
00589     virtual std::string arg_name(size_t i) {
00590       if ( i < 6+1 ) return m_arg_names[i];
00591       return std::string();
00592     }
00593 
00594     virtual void set_arg_name(size_t i, const std::string& name) {
00595       if ( i < 6+1 ) m_arg_names[i] = name;
00596     }
00597 
00598   protected:
00599 
00600     std::string m_arg_names[6+1];
00601 
00602     sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
00603 
00604   };
00605 
00606 
00613   template <>
00614   class Method <void, nil,nil,nil,nil,nil,nil,nil>
00615     : public MethodBase
00616   {
00617   public:
00618 
00619     typedef DBusCxxPointer<Method> pointer;
00620 
00621     Method(const std::string& name): MethodBase(name) {  }
00622     
00623     virtual ~Method() { }
00624 
00625     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00626                                                CallMessage::const_pointer message )
00627   {
00628     DBUS_CXX_DEBUG("Method<T_return>::handle_call_message   method=" << m_name );
00629       
00630     if ( not connection or not message ) return NOT_HANDLED;
00631 
00632 
00633 
00634     m_slot();
00635 
00636     return HANDLED;
00637   }
00638 
00639 
00640 
00641     void set_method( sigc::slot0<void> slot )
00642     { m_slot = slot; }
00643 
00644     static pointer create(const std::string& name)
00645     { return pointer( new Method(name) ); }
00646 
00647     virtual MethodBase::pointer clone()
00648     { return MethodBase::pointer( new Method(this->name()) ); }
00649 
00651     virtual std::string introspect(int space_depth=0) const
00652     {
00653       std::ostringstream sout;
00654       std::string spaces;
00655       for (int i=0; i < space_depth; i++ ) spaces += " ";
00656       sout << spaces << "<method name=\"" << name() << "\">\n";
00657       sout << spaces << "</method>\n";
00658       return sout.str();
00659     }
00660 
00661     virtual std::string arg_name(size_t i) {
00662       if ( i < 0+1 ) return m_arg_names[i];
00663       return std::string();
00664     }
00665 
00666     virtual void set_arg_name(size_t i, const std::string& name) {
00667       if ( i < 0+1 ) m_arg_names[i] = name;
00668     }
00669 
00670   protected:
00671 
00672     std::string m_arg_names[0+1];
00673 
00674     sigc::slot0<void> m_slot;
00675 
00676   };
00677 
00684   template <class T_arg1>
00685   class Method <void, T_arg1, nil,nil,nil,nil,nil,nil>
00686     : public MethodBase
00687   {
00688   public:
00689 
00690     typedef DBusCxxPointer<Method> pointer;
00691 
00692     Method(const std::string& name): MethodBase(name) {  }
00693     
00694     virtual ~Method() { }
00695 
00696     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00697                                                CallMessage::const_pointer message )
00698   {
00699     DBUS_CXX_DEBUG("Method<T_return, T_arg1>::handle_call_message   method=" << m_name );
00700       
00701     if ( not connection or not message ) return NOT_HANDLED;
00702 
00703     T_arg1 _val_1;
00704 
00705     try {
00706       Message::iterator i = message->begin();
00707       i  >> _val_1;
00708     }
00709     catch ( ErrorInvalidTypecast& e ) {
00710         return NOT_HANDLED;
00711     }
00712 
00713     m_slot(_val_1);
00714 
00715     return HANDLED;
00716   }
00717 
00718 
00719 
00720     void set_method( sigc::slot1<void, T_arg1> slot )
00721     { m_slot = slot; }
00722 
00723     static pointer create(const std::string& name)
00724     { return pointer( new Method(name) ); }
00725 
00726     virtual MethodBase::pointer clone()
00727     { return MethodBase::pointer( new Method(this->name()) ); }
00728 
00730     virtual std::string introspect(int space_depth=0) const
00731     {
00732       std::ostringstream sout;
00733       std::string spaces;
00734       for (int i=0; i < space_depth; i++ ) spaces += " ";
00735       sout << spaces << "<method name=\"" << name() << "\">\n";
00736       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00737            << "\" type=\"" << signature<T_arg1>()
00738            << "\" direction=\"in\"/>\n";
00739       sout << spaces << "</method>\n";
00740       return sout.str();
00741     }
00742 
00743     virtual std::string arg_name(size_t i) {
00744       if ( i < 1+1 ) return m_arg_names[i];
00745       return std::string();
00746     }
00747 
00748     virtual void set_arg_name(size_t i, const std::string& name) {
00749       if ( i < 1+1 ) m_arg_names[i] = name;
00750     }
00751 
00752   protected:
00753 
00754     std::string m_arg_names[1+1];
00755 
00756     sigc::slot1<void, T_arg1> m_slot;
00757 
00758   };
00759 
00766   template <class T_arg1,class T_arg2>
00767   class Method <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00768     : public MethodBase
00769   {
00770   public:
00771 
00772     typedef DBusCxxPointer<Method> pointer;
00773 
00774     Method(const std::string& name): MethodBase(name) {  }
00775     
00776     virtual ~Method() { }
00777 
00778     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00779                                                CallMessage::const_pointer message )
00780   {
00781     DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::handle_call_message   method=" << m_name );
00782       
00783     if ( not connection or not message ) return NOT_HANDLED;
00784 
00785     T_arg1 _val_1;
00786     T_arg2 _val_2;
00787 
00788     try {
00789       Message::iterator i = message->begin();
00790       i  >> _val_1 >> _val_2;
00791     }
00792     catch ( ErrorInvalidTypecast& e ) {
00793         return NOT_HANDLED;
00794     }
00795 
00796     m_slot(_val_1,_val_2);
00797 
00798     return HANDLED;
00799   }
00800 
00801 
00802 
00803     void set_method( sigc::slot2<void, T_arg1,T_arg2> slot )
00804     { m_slot = slot; }
00805 
00806     static pointer create(const std::string& name)
00807     { return pointer( new Method(name) ); }
00808 
00809     virtual MethodBase::pointer clone()
00810     { return MethodBase::pointer( new Method(this->name()) ); }
00811 
00813     virtual std::string introspect(int space_depth=0) const
00814     {
00815       std::ostringstream sout;
00816       std::string spaces;
00817       for (int i=0; i < space_depth; i++ ) spaces += " ";
00818       sout << spaces << "<method name=\"" << name() << "\">\n";
00819       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00820            << "\" type=\"" << signature<T_arg1>()
00821            << "\" direction=\"in\"/>\n";
00822       sout << spaces << "  <arg name=\"" << m_arg_names[2]
00823            << "\" type=\"" << signature<T_arg2>()
00824            << "\" direction=\"in\"/>\n";
00825       sout << spaces << "</method>\n";
00826       return sout.str();
00827     }
00828 
00829     virtual std::string arg_name(size_t i) {
00830       if ( i < 2+1 ) return m_arg_names[i];
00831       return std::string();
00832     }
00833 
00834     virtual void set_arg_name(size_t i, const std::string& name) {
00835       if ( i < 2+1 ) m_arg_names[i] = name;
00836     }
00837 
00838   protected:
00839 
00840     std::string m_arg_names[2+1];
00841 
00842     sigc::slot2<void, T_arg1,T_arg2> m_slot;
00843 
00844   };
00845 
00852   template <class T_arg1,class T_arg2,class T_arg3>
00853   class Method <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00854     : public MethodBase
00855   {
00856   public:
00857 
00858     typedef DBusCxxPointer<Method> pointer;
00859 
00860     Method(const std::string& name): MethodBase(name) {  }
00861     
00862     virtual ~Method() { }
00863 
00864     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00865                                                CallMessage::const_pointer message )
00866   {
00867     DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::handle_call_message   method=" << m_name );
00868       
00869     if ( not connection or not message ) return NOT_HANDLED;
00870 
00871     T_arg1 _val_1;
00872     T_arg2 _val_2;
00873     T_arg3 _val_3;
00874 
00875     try {
00876       Message::iterator i = message->begin();
00877       i  >> _val_1 >> _val_2 >> _val_3;
00878     }
00879     catch ( ErrorInvalidTypecast& e ) {
00880         return NOT_HANDLED;
00881     }
00882 
00883     m_slot(_val_1,_val_2,_val_3);
00884 
00885     return HANDLED;
00886   }
00887 
00888 
00889 
00890     void set_method( sigc::slot3<void, T_arg1,T_arg2,T_arg3> slot )
00891     { m_slot = slot; }
00892 
00893     static pointer create(const std::string& name)
00894     { return pointer( new Method(name) ); }
00895 
00896     virtual MethodBase::pointer clone()
00897     { return MethodBase::pointer( new Method(this->name()) ); }
00898 
00900     virtual std::string introspect(int space_depth=0) const
00901     {
00902       std::ostringstream sout;
00903       std::string spaces;
00904       for (int i=0; i < space_depth; i++ ) spaces += " ";
00905       sout << spaces << "<method name=\"" << name() << "\">\n";
00906       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00907            << "\" type=\"" << signature<T_arg1>()
00908            << "\" direction=\"in\"/>\n";
00909       sout << spaces << "  <arg name=\"" << m_arg_names[2]
00910            << "\" type=\"" << signature<T_arg2>()
00911            << "\" direction=\"in\"/>\n";
00912       sout << spaces << "  <arg name=\"" << m_arg_names[3]
00913            << "\" type=\"" << signature<T_arg3>()
00914            << "\" direction=\"in\"/>\n";
00915       sout << spaces << "</method>\n";
00916       return sout.str();
00917     }
00918 
00919     virtual std::string arg_name(size_t i) {
00920       if ( i < 3+1 ) return m_arg_names[i];
00921       return std::string();
00922     }
00923 
00924     virtual void set_arg_name(size_t i, const std::string& name) {
00925       if ( i < 3+1 ) m_arg_names[i] = name;
00926     }
00927 
00928   protected:
00929 
00930     std::string m_arg_names[3+1];
00931 
00932     sigc::slot3<void, T_arg1,T_arg2,T_arg3> m_slot;
00933 
00934   };
00935 
00942   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00943   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00944     : public MethodBase
00945   {
00946   public:
00947 
00948     typedef DBusCxxPointer<Method> pointer;
00949 
00950     Method(const std::string& name): MethodBase(name) {  }
00951     
00952     virtual ~Method() { }
00953 
00954     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
00955                                                CallMessage::const_pointer message )
00956   {
00957     DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message   method=" << m_name );
00958       
00959     if ( not connection or not message ) return NOT_HANDLED;
00960 
00961     T_arg1 _val_1;
00962     T_arg2 _val_2;
00963     T_arg3 _val_3;
00964     T_arg4 _val_4;
00965 
00966     try {
00967       Message::iterator i = message->begin();
00968       i  >> _val_1 >> _val_2 >> _val_3 >> _val_4;
00969     }
00970     catch ( ErrorInvalidTypecast& e ) {
00971         return NOT_HANDLED;
00972     }
00973 
00974     m_slot(_val_1,_val_2,_val_3,_val_4);
00975 
00976     return HANDLED;
00977   }
00978 
00979 
00980 
00981     void set_method( sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> slot )
00982     { m_slot = slot; }
00983 
00984     static pointer create(const std::string& name)
00985     { return pointer( new Method(name) ); }
00986 
00987     virtual MethodBase::pointer clone()
00988     { return MethodBase::pointer( new Method(this->name()) ); }
00989 
00991     virtual std::string introspect(int space_depth=0) const
00992     {
00993       std::ostringstream sout;
00994       std::string spaces;
00995       for (int i=0; i < space_depth; i++ ) spaces += " ";
00996       sout << spaces << "<method name=\"" << name() << "\">\n";
00997       sout << spaces << "  <arg name=\"" << m_arg_names[1]
00998            << "\" type=\"" << signature<T_arg1>()
00999            << "\" direction=\"in\"/>\n";
01000       sout << spaces << "  <arg name=\"" << m_arg_names[2]
01001            << "\" type=\"" << signature<T_arg2>()
01002            << "\" direction=\"in\"/>\n";
01003       sout << spaces << "  <arg name=\"" << m_arg_names[3]
01004            << "\" type=\"" << signature<T_arg3>()
01005            << "\" direction=\"in\"/>\n";
01006       sout << spaces << "  <arg name=\"" << m_arg_names[4]
01007            << "\" type=\"" << signature<T_arg4>()
01008            << "\" direction=\"in\"/>\n";
01009       sout << spaces << "</method>\n";
01010       return sout.str();
01011     }
01012 
01013     virtual std::string arg_name(size_t i) {
01014       if ( i < 4+1 ) return m_arg_names[i];
01015       return std::string();
01016     }
01017 
01018     virtual void set_arg_name(size_t i, const std::string& name) {
01019       if ( i < 4+1 ) m_arg_names[i] = name;
01020     }
01021 
01022   protected:
01023 
01024     std::string m_arg_names[4+1];
01025 
01026     sigc::slot4<void, T_arg1,T_arg2,T_arg3,T_arg4> m_slot;
01027 
01028   };
01029 
01036   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
01037   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
01038     : public MethodBase
01039   {
01040   public:
01041 
01042     typedef DBusCxxPointer<Method> pointer;
01043 
01044     Method(const std::string& name): MethodBase(name) {  }
01045     
01046     virtual ~Method() { }
01047 
01048     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
01049                                                CallMessage::const_pointer message )
01050   {
01051     DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message   method=" << m_name );
01052       
01053     if ( not connection or not message ) return NOT_HANDLED;
01054 
01055     T_arg1 _val_1;
01056     T_arg2 _val_2;
01057     T_arg3 _val_3;
01058     T_arg4 _val_4;
01059     T_arg5 _val_5;
01060 
01061     try {
01062       Message::iterator i = message->begin();
01063       i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
01064     }
01065     catch ( ErrorInvalidTypecast& e ) {
01066         return NOT_HANDLED;
01067     }
01068 
01069     m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
01070 
01071     return HANDLED;
01072   }
01073 
01074 
01075 
01076     void set_method( sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
01077     { m_slot = slot; }
01078 
01079     static pointer create(const std::string& name)
01080     { return pointer( new Method(name) ); }
01081 
01082     virtual MethodBase::pointer clone()
01083     { return MethodBase::pointer( new Method(this->name()) ); }
01084 
01086     virtual std::string introspect(int space_depth=0) const
01087     {
01088       std::ostringstream sout;
01089       std::string spaces;
01090       for (int i=0; i < space_depth; i++ ) spaces += " ";
01091       sout << spaces << "<method name=\"" << name() << "\">\n";
01092       sout << spaces << "  <arg name=\"" << m_arg_names[1]
01093            << "\" type=\"" << signature<T_arg1>()
01094            << "\" direction=\"in\"/>\n";
01095       sout << spaces << "  <arg name=\"" << m_arg_names[2]
01096            << "\" type=\"" << signature<T_arg2>()
01097            << "\" direction=\"in\"/>\n";
01098       sout << spaces << "  <arg name=\"" << m_arg_names[3]
01099            << "\" type=\"" << signature<T_arg3>()
01100            << "\" direction=\"in\"/>\n";
01101       sout << spaces << "  <arg name=\"" << m_arg_names[4]
01102            << "\" type=\"" << signature<T_arg4>()
01103            << "\" direction=\"in\"/>\n";
01104       sout << spaces << "  <arg name=\"" << m_arg_names[5]
01105            << "\" type=\"" << signature<T_arg5>()
01106            << "\" direction=\"in\"/>\n";
01107       sout << spaces << "</method>\n";
01108       return sout.str();
01109     }
01110 
01111     virtual std::string arg_name(size_t i) {
01112       if ( i < 5+1 ) return m_arg_names[i];
01113       return std::string();
01114     }
01115 
01116     virtual void set_arg_name(size_t i, const std::string& name) {
01117       if ( i < 5+1 ) m_arg_names[i] = name;
01118     }
01119 
01120   protected:
01121 
01122     std::string m_arg_names[5+1];
01123 
01124     sigc::slot5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> m_slot;
01125 
01126   };
01127 
01134   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
01135   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
01136     : public MethodBase
01137   {
01138   public:
01139 
01140     typedef DBusCxxPointer<Method> pointer;
01141 
01142     Method(const std::string& name): MethodBase(name) {  }
01143     
01144     virtual ~Method() { }
01145 
01146     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
01147                                                CallMessage::const_pointer message )
01148   {
01149     DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message   method=" << m_name );
01150       
01151     if ( not connection or not message ) return NOT_HANDLED;
01152 
01153     T_arg1 _val_1;
01154     T_arg2 _val_2;
01155     T_arg3 _val_3;
01156     T_arg4 _val_4;
01157     T_arg5 _val_5;
01158     T_arg6 _val_6;
01159 
01160     try {
01161       Message::iterator i = message->begin();
01162       i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
01163     }
01164     catch ( ErrorInvalidTypecast& e ) {
01165         return NOT_HANDLED;
01166     }
01167 
01168     m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
01169 
01170     return HANDLED;
01171   }
01172 
01173 
01174 
01175     void set_method( sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
01176     { m_slot = slot; }
01177 
01178     static pointer create(const std::string& name)
01179     { return pointer( new Method(name) ); }
01180 
01181     virtual MethodBase::pointer clone()
01182     { return MethodBase::pointer( new Method(this->name()) ); }
01183 
01185     virtual std::string introspect(int space_depth=0) const
01186     {
01187       std::ostringstream sout;
01188       std::string spaces;
01189       for (int i=0; i < space_depth; i++ ) spaces += " ";
01190       sout << spaces << "<method name=\"" << name() << "\">\n";
01191       sout << spaces << "  <arg name=\"" << m_arg_names[1]
01192            << "\" type=\"" << signature<T_arg1>()
01193            << "\" direction=\"in\"/>\n";
01194       sout << spaces << "  <arg name=\"" << m_arg_names[2]
01195            << "\" type=\"" << signature<T_arg2>()
01196            << "\" direction=\"in\"/>\n";
01197       sout << spaces << "  <arg name=\"" << m_arg_names[3]
01198            << "\" type=\"" << signature<T_arg3>()
01199            << "\" direction=\"in\"/>\n";
01200       sout << spaces << "  <arg name=\"" << m_arg_names[4]
01201            << "\" type=\"" << signature<T_arg4>()
01202            << "\" direction=\"in\"/>\n";
01203       sout << spaces << "  <arg name=\"" << m_arg_names[5]
01204            << "\" type=\"" << signature<T_arg5>()
01205            << "\" direction=\"in\"/>\n";
01206       sout << spaces << "  <arg name=\"" << m_arg_names[6]
01207            << "\" type=\"" << signature<T_arg6>()
01208            << "\" direction=\"in\"/>\n";
01209       sout << spaces << "</method>\n";
01210       return sout.str();
01211     }
01212 
01213     virtual std::string arg_name(size_t i) {
01214       if ( i < 6+1 ) return m_arg_names[i];
01215       return std::string();
01216     }
01217 
01218     virtual void set_arg_name(size_t i, const std::string& name) {
01219       if ( i < 6+1 ) m_arg_names[i] = name;
01220     }
01221 
01222   protected:
01223 
01224     std::string m_arg_names[6+1];
01225 
01226     sigc::slot6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> m_slot;
01227 
01228   };
01229 
01236   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
01237   class Method <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
01238     : public MethodBase
01239   {
01240   public:
01241 
01242     typedef DBusCxxPointer<Method> pointer;
01243 
01244     Method(const std::string& name): MethodBase(name) {  }
01245     
01246     virtual ~Method() { }
01247 
01248     virtual HandlerResult handle_call_message( DBusCxxPointer<Connection> connection,
01249                                                CallMessage::const_pointer message )
01250   {
01251     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 );
01252       
01253     if ( not connection or not message ) return NOT_HANDLED;
01254 
01255     T_arg1 _val_1;
01256     T_arg2 _val_2;
01257     T_arg3 _val_3;
01258     T_arg4 _val_4;
01259     T_arg5 _val_5;
01260     T_arg6 _val_6;
01261     T_arg7 _val_7;
01262 
01263     try {
01264       Message::iterator i = message->begin();
01265       i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
01266     }
01267     catch ( ErrorInvalidTypecast& e ) {
01268         return NOT_HANDLED;
01269     }
01270 
01271     m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
01272 
01273     return HANDLED;
01274   }
01275 
01276 
01277 
01278     void set_method( sigc::slot7<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot )
01279     { m_slot = slot; }
01280 
01281     static pointer create(const std::string& name)
01282     { return pointer( new Method(name) ); }
01283 
01284     virtual MethodBase::pointer clone()
01285     { return MethodBase::pointer( new Method(this->name()) ); }
01286 
01288     virtual std::string introspect(int space_depth=0) const
01289     {
01290       std::ostringstream sout;
01291       std::string spaces;
01292       for (int i=0; i < space_depth; i++ ) spaces += " ";
01293       sout << spaces << "<method name=\"" << name() << "\">\n";
01294       sout << spaces << "  <arg name=\"" << m_arg_names[1]
01295            << "\" type=\"" << signature<T_arg1>()
01296            << "\" direction=\"in\"/>\n";
01297       sout << spaces << "  <arg name=\"" << m_arg_names[2]
01298            << "\" type=\"" << signature<T_arg2>()
01299            << "\" direction=\"in\"/>\n";
01300       sout << spaces << "  <arg name=\"" << m_arg_names[3]
01301            << "\" type=\"" << signature<T_arg3>()
01302            << "\" direction=\"in\"/>\n";
01303       sout << spaces << "  <arg name=\"" << m_arg_names[4]
01304            << "\" type=\"" << signature<T_arg4>()
01305            << "\" direction=\"in\"/>\n";
01306       sout << spaces << "  <arg name=\"" << m_arg_names[5]
01307            << "\" type=\"" << signature<T_arg5>()
01308            << "\" direction=\"in\"/>\n";
01309       sout << spaces << "  <arg name=\"" << m_arg_names[6]
01310            << "\" type=\"" << signature<T_arg6>()
01311            << "\" direction=\"in\"/>\n";
01312       sout << spaces << "  <arg name=\"" << m_arg_names[7]
01313            << "\" type=\"" << signature<T_arg7>()
01314            << "\" direction=\"in\"/>\n";
01315       sout << spaces << "</method>\n";
01316       return sout.str();
01317     }
01318 
01319     virtual std::string arg_name(size_t i) {
01320       if ( i < 7+1 ) return m_arg_names[i];
01321       return std::string();
01322     }
01323 
01324     virtual void set_arg_name(size_t i, const std::string& name) {
01325       if ( i < 7+1 ) m_arg_names[i] = name;
01326     }
01327 
01328   protected:
01329 
01330     std::string m_arg_names[7+1];
01331 
01332     sigc::slot7<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> m_slot;
01333 
01334   };
01335 
01336 
01337 
01338 } /* namespace DBus */
01339 
01340 #include <dbus-cxx/connection.h>
01341 
01342 namespace DBus {
01343 
01344   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
01345   HandlerResult Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01346   {
01347     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 );
01348       
01349     if ( not connection or not message ) return NOT_HANDLED;
01350 
01351     T_return _retval;
01352     T_arg1 _val_1;
01353     T_arg2 _val_2;
01354     T_arg3 _val_3;
01355     T_arg4 _val_4;
01356     T_arg5 _val_5;
01357     T_arg6 _val_6;
01358     T_arg7 _val_7;
01359 
01360     try {
01361       Message::iterator i = message->begin();
01362       i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6 >> _val_7;
01363     }
01364     catch ( ErrorInvalidTypecast& e ) {
01365         return NOT_HANDLED;
01366     }
01367 
01368     _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6,_val_7);
01369     ReturnMessage::pointer retmsg = message->create_reply();
01370 
01371     if ( not retmsg ) return NOT_HANDLED;
01372 
01373     *retmsg << _retval;
01374 
01375     connection->send(retmsg);
01376 
01377     return HANDLED;
01378   }
01379 
01380 
01381 
01382   template <class T_return>
01383   HandlerResult Method <T_return, nil,nil,nil,nil,nil,nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01384   {
01385     DBUS_CXX_DEBUG("Method<T_return>::handle_call_message   method=" << m_name );
01386       
01387     if ( not connection or not message ) return NOT_HANDLED;
01388 
01389     T_return _retval;
01390 
01391 
01392     _retval = m_slot();
01393     ReturnMessage::pointer retmsg = message->create_reply();
01394 
01395     if ( not retmsg ) return NOT_HANDLED;
01396 
01397     *retmsg << _retval;
01398 
01399     connection->send(retmsg);
01400 
01401     return HANDLED;
01402   }
01403 
01404 
01405   template <class T_return, class T_arg1>
01406   HandlerResult Method <T_return, T_arg1, nil,nil,nil,nil,nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01407   {
01408     DBUS_CXX_DEBUG("Method<T_return, T_arg1>::handle_call_message   method=" << m_name );
01409       
01410     if ( not connection or not message ) return NOT_HANDLED;
01411 
01412     T_return _retval;
01413     T_arg1 _val_1;
01414 
01415     try {
01416       Message::iterator i = message->begin();
01417       i  >> _val_1;
01418     }
01419     catch ( ErrorInvalidTypecast& e ) {
01420         return NOT_HANDLED;
01421     }
01422 
01423     _retval = m_slot(_val_1);
01424     ReturnMessage::pointer retmsg = message->create_reply();
01425 
01426     if ( not retmsg ) return NOT_HANDLED;
01427 
01428     *retmsg << _retval;
01429 
01430     connection->send(retmsg);
01431 
01432     return HANDLED;
01433   }
01434 
01435 
01436   template <class T_return, class T_arg1,class T_arg2>
01437   HandlerResult Method <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01438   {
01439     DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::handle_call_message   method=" << m_name );
01440       
01441     if ( not connection or not message ) return NOT_HANDLED;
01442 
01443     T_return _retval;
01444     T_arg1 _val_1;
01445     T_arg2 _val_2;
01446 
01447     try {
01448       Message::iterator i = message->begin();
01449       i  >> _val_1 >> _val_2;
01450     }
01451     catch ( ErrorInvalidTypecast& e ) {
01452         return NOT_HANDLED;
01453     }
01454 
01455     _retval = m_slot(_val_1,_val_2);
01456     ReturnMessage::pointer retmsg = message->create_reply();
01457 
01458     if ( not retmsg ) return NOT_HANDLED;
01459 
01460     *retmsg << _retval;
01461 
01462     connection->send(retmsg);
01463 
01464     return HANDLED;
01465   }
01466 
01467 
01468   template <class T_return, class T_arg1,class T_arg2,class T_arg3>
01469   HandlerResult Method <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01470   {
01471     DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::handle_call_message   method=" << m_name );
01472       
01473     if ( not connection or not message ) return NOT_HANDLED;
01474 
01475     T_return _retval;
01476     T_arg1 _val_1;
01477     T_arg2 _val_2;
01478     T_arg3 _val_3;
01479 
01480     try {
01481       Message::iterator i = message->begin();
01482       i  >> _val_1 >> _val_2 >> _val_3;
01483     }
01484     catch ( ErrorInvalidTypecast& e ) {
01485         return NOT_HANDLED;
01486     }
01487 
01488     _retval = m_slot(_val_1,_val_2,_val_3);
01489     ReturnMessage::pointer retmsg = message->create_reply();
01490 
01491     if ( not retmsg ) return NOT_HANDLED;
01492 
01493     *retmsg << _retval;
01494 
01495     connection->send(retmsg);
01496 
01497     return HANDLED;
01498   }
01499 
01500 
01501   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
01502   HandlerResult Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01503   {
01504     DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::handle_call_message   method=" << m_name );
01505       
01506     if ( not connection or not message ) return NOT_HANDLED;
01507 
01508     T_return _retval;
01509     T_arg1 _val_1;
01510     T_arg2 _val_2;
01511     T_arg3 _val_3;
01512     T_arg4 _val_4;
01513 
01514     try {
01515       Message::iterator i = message->begin();
01516       i  >> _val_1 >> _val_2 >> _val_3 >> _val_4;
01517     }
01518     catch ( ErrorInvalidTypecast& e ) {
01519         return NOT_HANDLED;
01520     }
01521 
01522     _retval = m_slot(_val_1,_val_2,_val_3,_val_4);
01523     ReturnMessage::pointer retmsg = message->create_reply();
01524 
01525     if ( not retmsg ) return NOT_HANDLED;
01526 
01527     *retmsg << _retval;
01528 
01529     connection->send(retmsg);
01530 
01531     return HANDLED;
01532   }
01533 
01534 
01535   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
01536   HandlerResult Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01537   {
01538     DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::handle_call_message   method=" << m_name );
01539       
01540     if ( not connection or not message ) return NOT_HANDLED;
01541 
01542     T_return _retval;
01543     T_arg1 _val_1;
01544     T_arg2 _val_2;
01545     T_arg3 _val_3;
01546     T_arg4 _val_4;
01547     T_arg5 _val_5;
01548 
01549     try {
01550       Message::iterator i = message->begin();
01551       i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5;
01552     }
01553     catch ( ErrorInvalidTypecast& e ) {
01554         return NOT_HANDLED;
01555     }
01556 
01557     _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5);
01558     ReturnMessage::pointer retmsg = message->create_reply();
01559 
01560     if ( not retmsg ) return NOT_HANDLED;
01561 
01562     *retmsg << _retval;
01563 
01564     connection->send(retmsg);
01565 
01566     return HANDLED;
01567   }
01568 
01569 
01570   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
01571   HandlerResult Method <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>::handle_call_message( DBusCxxPointer<Connection> connection, CallMessage::const_pointer message )
01572   {
01573     DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::handle_call_message   method=" << m_name );
01574       
01575     if ( not connection or not message ) return NOT_HANDLED;
01576 
01577     T_return _retval;
01578     T_arg1 _val_1;
01579     T_arg2 _val_2;
01580     T_arg3 _val_3;
01581     T_arg4 _val_4;
01582     T_arg5 _val_5;
01583     T_arg6 _val_6;
01584 
01585     try {
01586       Message::iterator i = message->begin();
01587       i  >> _val_1 >> _val_2 >> _val_3 >> _val_4 >> _val_5 >> _val_6;
01588     }
01589     catch ( ErrorInvalidTypecast& e ) {
01590         return NOT_HANDLED;
01591     }
01592 
01593     _retval = m_slot(_val_1,_val_2,_val_3,_val_4,_val_5,_val_6);
01594     ReturnMessage::pointer retmsg = message->create_reply();
01595 
01596     if ( not retmsg ) return NOT_HANDLED;
01597 
01598     *retmsg << _retval;
01599 
01600     connection->send(retmsg);
01601 
01602     return HANDLED;
01603   }
01604 
01605 
01606 
01607 
01608 } /* namespace DBus */
01609 
01610 #endif /* DBUS_CXX_METHOD_H */
01611 

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