dbus-cxx logo

methodproxy.h

Go to the documentation of this file.
00001 
00002 // -*- c++ -*-
00003 /* Do not edit! -- generated file */
00004 
00005 #ifndef DBUSCXXMETHODPROXY_H
00006 #define DBUSCXXMETHODPROXY_H
00007 
00008 #include <dbus-cxx/methodproxybase.h>
00009 
00010 namespace DBus {
00011 
00012 
00019   template <class T_return, class T_arg1 = nil,class T_arg2 = nil,class T_arg3 = nil,class T_arg4 = nil,class T_arg5 = nil,class T_arg6 = nil,class T_arg7 = nil>
00020   class MethodProxy 
00021     : public MethodProxyBase
00022   {
00023   public:
00024 
00025     typedef DBusCxxPointer<MethodProxy> pointer;
00026 
00027     MethodProxy(const std::string& name):
00028       MethodProxyBase(name)
00029     {  }
00030 
00031     T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5,T_arg6 _val_6,T_arg7 _val_7)
00032     {
00033       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::operator()   method=" << m_name );
00034       CallMessage::pointer _callmsg = this->create_call_message();
00035       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6 << _val_7;
00036       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00037       T_return _retval;
00038       retmsg >> _retval;
00039       return _retval;
00040     }
00041 
00042     static pointer create(const std::string& name)
00043     { return pointer( new MethodProxy(name) ); }
00044 
00045   };
00046 
00047 
00048 
00055   template <class T_return>
00056   class MethodProxy <T_return, nil,nil,nil,nil,nil,nil,nil>
00057     : public MethodProxyBase
00058   {
00059   public:
00060 
00061     typedef DBusCxxPointer<MethodProxy> pointer;
00062 
00063     MethodProxy(const std::string& name):
00064       MethodProxyBase(name)
00065     {  }
00066 
00067     T_return operator()()
00068     {
00069       DBUS_CXX_DEBUG("Method<T_return>::operator()   method=" << m_name );
00070       CallMessage::pointer _callmsg = this->create_call_message();
00071       
00072       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00073       T_return _retval;
00074       retmsg >> _retval;
00075       return _retval;
00076     }
00077 
00078     static pointer create(const std::string& name)
00079     { return pointer( new MethodProxy(name) ); }
00080 
00081   };
00082 
00083 
00090   template <class T_return, class T_arg1>
00091   class MethodProxy <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00092     : public MethodProxyBase
00093   {
00094   public:
00095 
00096     typedef DBusCxxPointer<MethodProxy> pointer;
00097 
00098     MethodProxy(const std::string& name):
00099       MethodProxyBase(name)
00100     {  }
00101 
00102     T_return operator()(T_arg1 _val_1)
00103     {
00104       DBUS_CXX_DEBUG("Method<T_return, T_arg1>::operator()   method=" << m_name );
00105       CallMessage::pointer _callmsg = this->create_call_message();
00106       *_callmsg  << _val_1;
00107       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00108       T_return _retval;
00109       retmsg >> _retval;
00110       return _retval;
00111     }
00112 
00113     static pointer create(const std::string& name)
00114     { return pointer( new MethodProxy(name) ); }
00115 
00116   };
00117 
00118 
00125   template <class T_return, class T_arg1,class T_arg2>
00126   class MethodProxy <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00127     : public MethodProxyBase
00128   {
00129   public:
00130 
00131     typedef DBusCxxPointer<MethodProxy> pointer;
00132 
00133     MethodProxy(const std::string& name):
00134       MethodProxyBase(name)
00135     {  }
00136 
00137     T_return operator()(T_arg1 _val_1,T_arg2 _val_2)
00138     {
00139       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::operator()   method=" << m_name );
00140       CallMessage::pointer _callmsg = this->create_call_message();
00141       *_callmsg  << _val_1 << _val_2;
00142       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00143       T_return _retval;
00144       retmsg >> _retval;
00145       return _retval;
00146     }
00147 
00148     static pointer create(const std::string& name)
00149     { return pointer( new MethodProxy(name) ); }
00150 
00151   };
00152 
00153 
00160   template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00161   class MethodProxy <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00162     : public MethodProxyBase
00163   {
00164   public:
00165 
00166     typedef DBusCxxPointer<MethodProxy> pointer;
00167 
00168     MethodProxy(const std::string& name):
00169       MethodProxyBase(name)
00170     {  }
00171 
00172     T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3)
00173     {
00174       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::operator()   method=" << m_name );
00175       CallMessage::pointer _callmsg = this->create_call_message();
00176       *_callmsg  << _val_1 << _val_2 << _val_3;
00177       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00178       T_return _retval;
00179       retmsg >> _retval;
00180       return _retval;
00181     }
00182 
00183     static pointer create(const std::string& name)
00184     { return pointer( new MethodProxy(name) ); }
00185 
00186   };
00187 
00188 
00195   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00196   class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00197     : public MethodProxyBase
00198   {
00199   public:
00200 
00201     typedef DBusCxxPointer<MethodProxy> pointer;
00202 
00203     MethodProxy(const std::string& name):
00204       MethodProxyBase(name)
00205     {  }
00206 
00207     T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4)
00208     {
00209       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::operator()   method=" << m_name );
00210       CallMessage::pointer _callmsg = this->create_call_message();
00211       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4;
00212       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00213       T_return _retval;
00214       retmsg >> _retval;
00215       return _retval;
00216     }
00217 
00218     static pointer create(const std::string& name)
00219     { return pointer( new MethodProxy(name) ); }
00220 
00221   };
00222 
00223 
00230   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00231   class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00232     : public MethodProxyBase
00233   {
00234   public:
00235 
00236     typedef DBusCxxPointer<MethodProxy> pointer;
00237 
00238     MethodProxy(const std::string& name):
00239       MethodProxyBase(name)
00240     {  }
00241 
00242     T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5)
00243     {
00244       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::operator()   method=" << m_name );
00245       CallMessage::pointer _callmsg = this->create_call_message();
00246       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4 << _val_5;
00247       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00248       T_return _retval;
00249       retmsg >> _retval;
00250       return _retval;
00251     }
00252 
00253     static pointer create(const std::string& name)
00254     { return pointer( new MethodProxy(name) ); }
00255 
00256   };
00257 
00258 
00265   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00266   class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00267     : public MethodProxyBase
00268   {
00269   public:
00270 
00271     typedef DBusCxxPointer<MethodProxy> pointer;
00272 
00273     MethodProxy(const std::string& name):
00274       MethodProxyBase(name)
00275     {  }
00276 
00277     T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5,T_arg6 _val_6)
00278     {
00279       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::operator()   method=" << m_name );
00280       CallMessage::pointer _callmsg = this->create_call_message();
00281       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6;
00282       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00283       T_return _retval;
00284       retmsg >> _retval;
00285       return _retval;
00286     }
00287 
00288     static pointer create(const std::string& name)
00289     { return pointer( new MethodProxy(name) ); }
00290 
00291   };
00292 
00293 
00296   template <>
00297   class MethodProxy <void, nil,nil,nil,nil,nil,nil,nil>
00298     : public MethodProxyBase
00299   {
00300   public:
00301 
00302     typedef DBusCxxPointer<MethodProxy> pointer;
00303 
00304     MethodProxy(const std::string& name):
00305       MethodProxyBase(name)
00306     {  }
00307 
00308     void operator()()
00309     {
00310       DBUS_CXX_DEBUG("Method<T_return>::operator()   method=" << m_name );
00311       CallMessage::pointer _callmsg = this->create_call_message();
00312       *_callmsg ;
00313       _callmsg->set_no_reply();
00314       this->call( _callmsg );
00315     }
00316 
00317     static pointer create(const std::string& name)
00318     { return pointer( new MethodProxy(name) ); }
00319 
00320   };
00321 
00324   template <class T_arg1>
00325   class MethodProxy <void, T_arg1, nil,nil,nil,nil,nil,nil>
00326     : public MethodProxyBase
00327   {
00328   public:
00329 
00330     typedef DBusCxxPointer<MethodProxy> pointer;
00331 
00332     MethodProxy(const std::string& name):
00333       MethodProxyBase(name)
00334     {  }
00335 
00336     void operator()(T_arg1 _val_1)
00337     {
00338       DBUS_CXX_DEBUG("Method<T_return, T_arg1>::operator()   method=" << m_name );
00339       CallMessage::pointer _callmsg = this->create_call_message();
00340       *_callmsg  << _val_1;
00341       _callmsg->set_no_reply();
00342       this->call( _callmsg );
00343     }
00344 
00345     static pointer create(const std::string& name)
00346     { return pointer( new MethodProxy(name) ); }
00347 
00348   };
00349 
00352   template <class T_arg1,class T_arg2>
00353   class MethodProxy <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00354     : public MethodProxyBase
00355   {
00356   public:
00357 
00358     typedef DBusCxxPointer<MethodProxy> pointer;
00359 
00360     MethodProxy(const std::string& name):
00361       MethodProxyBase(name)
00362     {  }
00363 
00364     void operator()(T_arg1 _val_1,T_arg2 _val_2)
00365     {
00366       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::operator()   method=" << m_name );
00367       CallMessage::pointer _callmsg = this->create_call_message();
00368       *_callmsg  << _val_1 << _val_2;
00369       _callmsg->set_no_reply();
00370       this->call( _callmsg );
00371     }
00372 
00373     static pointer create(const std::string& name)
00374     { return pointer( new MethodProxy(name) ); }
00375 
00376   };
00377 
00380   template <class T_arg1,class T_arg2,class T_arg3>
00381   class MethodProxy <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00382     : public MethodProxyBase
00383   {
00384   public:
00385 
00386     typedef DBusCxxPointer<MethodProxy> pointer;
00387 
00388     MethodProxy(const std::string& name):
00389       MethodProxyBase(name)
00390     {  }
00391 
00392     void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3)
00393     {
00394       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::operator()   method=" << m_name );
00395       CallMessage::pointer _callmsg = this->create_call_message();
00396       *_callmsg  << _val_1 << _val_2 << _val_3;
00397       _callmsg->set_no_reply();
00398       this->call( _callmsg );
00399     }
00400 
00401     static pointer create(const std::string& name)
00402     { return pointer( new MethodProxy(name) ); }
00403 
00404   };
00405 
00408   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00409   class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00410     : public MethodProxyBase
00411   {
00412   public:
00413 
00414     typedef DBusCxxPointer<MethodProxy> pointer;
00415 
00416     MethodProxy(const std::string& name):
00417       MethodProxyBase(name)
00418     {  }
00419 
00420     void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4)
00421     {
00422       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::operator()   method=" << m_name );
00423       CallMessage::pointer _callmsg = this->create_call_message();
00424       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4;
00425       _callmsg->set_no_reply();
00426       this->call( _callmsg );
00427     }
00428 
00429     static pointer create(const std::string& name)
00430     { return pointer( new MethodProxy(name) ); }
00431 
00432   };
00433 
00436   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00437   class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00438     : public MethodProxyBase
00439   {
00440   public:
00441 
00442     typedef DBusCxxPointer<MethodProxy> pointer;
00443 
00444     MethodProxy(const std::string& name):
00445       MethodProxyBase(name)
00446     {  }
00447 
00448     void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5)
00449     {
00450       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::operator()   method=" << m_name );
00451       CallMessage::pointer _callmsg = this->create_call_message();
00452       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4 << _val_5;
00453       _callmsg->set_no_reply();
00454       this->call( _callmsg );
00455     }
00456 
00457     static pointer create(const std::string& name)
00458     { return pointer( new MethodProxy(name) ); }
00459 
00460   };
00461 
00464   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00465   class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00466     : public MethodProxyBase
00467   {
00468   public:
00469 
00470     typedef DBusCxxPointer<MethodProxy> pointer;
00471 
00472     MethodProxy(const std::string& name):
00473       MethodProxyBase(name)
00474     {  }
00475 
00476     void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5,T_arg6 _val_6)
00477     {
00478       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::operator()   method=" << m_name );
00479       CallMessage::pointer _callmsg = this->create_call_message();
00480       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6;
00481       _callmsg->set_no_reply();
00482       this->call( _callmsg );
00483     }
00484 
00485     static pointer create(const std::string& name)
00486     { return pointer( new MethodProxy(name) ); }
00487 
00488   };
00489 
00490 
00491 
00492 }
00493 
00494 #endif

Generated on Mon Sep 21 10:59:27 2009 for dbus-cxx by doxygen 1.6.1