dbus-cxx logo

methodproxy.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/forward_decls.h>
00024 #include <dbus-cxx/methodproxybase.h>
00025 #include <dbus-cxx/utility.h>
00026 
00027 #ifndef DBUSCXX_METHODPROXY_H
00028 #define DBUSCXX_METHODPROXY_H
00029 
00030 namespace DBus {
00031 
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 MethodProxy 
00041     : public MethodProxyBase
00042   {
00043   public:
00044 
00045     typedef DBusCxxPointer<MethodProxy> pointer;
00046 
00047     MethodProxy(const std::string& name):
00048       MethodProxyBase(name)
00049     {  }
00050 
00051     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)
00052     {
00053       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::operator()   method=" << m_name );
00054       CallMessage::pointer _callmsg = this->create_call_message();
00055       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6 << _val_7;
00056       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00057       T_return _retval;
00058       retmsg >> _retval;
00059       return _retval;
00060     }
00061 
00062     static pointer create(const std::string& name)
00063     { return pointer( new MethodProxy(name) ); }
00064 
00065   };
00066 
00067 
00068 
00075   template <class T_return>
00076   class MethodProxy <T_return, nil,nil,nil,nil,nil,nil,nil>
00077     : public MethodProxyBase
00078   {
00079   public:
00080 
00081     typedef DBusCxxPointer<MethodProxy> pointer;
00082 
00083     MethodProxy(const std::string& name):
00084       MethodProxyBase(name)
00085     {  }
00086 
00087     T_return operator()()
00088     {
00089       DBUS_CXX_DEBUG("Method<T_return>::operator()   method=" << m_name );
00090       CallMessage::pointer _callmsg = this->create_call_message();
00091       
00092       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00093       T_return _retval;
00094       retmsg >> _retval;
00095       return _retval;
00096     }
00097 
00098     static pointer create(const std::string& name)
00099     { return pointer( new MethodProxy(name) ); }
00100 
00101   };
00102 
00103 
00110   template <class T_return, class T_arg1>
00111   class MethodProxy <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00112     : public MethodProxyBase
00113   {
00114   public:
00115 
00116     typedef DBusCxxPointer<MethodProxy> pointer;
00117 
00118     MethodProxy(const std::string& name):
00119       MethodProxyBase(name)
00120     {  }
00121 
00122     T_return operator()(T_arg1 _val_1)
00123     {
00124       DBUS_CXX_DEBUG("Method<T_return, T_arg1>::operator()   method=" << m_name );
00125       CallMessage::pointer _callmsg = this->create_call_message();
00126       *_callmsg  << _val_1;
00127       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00128       T_return _retval;
00129       retmsg >> _retval;
00130       return _retval;
00131     }
00132 
00133     static pointer create(const std::string& name)
00134     { return pointer( new MethodProxy(name) ); }
00135 
00136   };
00137 
00138 
00145   template <class T_return, class T_arg1,class T_arg2>
00146   class MethodProxy <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00147     : public MethodProxyBase
00148   {
00149   public:
00150 
00151     typedef DBusCxxPointer<MethodProxy> pointer;
00152 
00153     MethodProxy(const std::string& name):
00154       MethodProxyBase(name)
00155     {  }
00156 
00157     T_return operator()(T_arg1 _val_1,T_arg2 _val_2)
00158     {
00159       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::operator()   method=" << m_name );
00160       CallMessage::pointer _callmsg = this->create_call_message();
00161       *_callmsg  << _val_1 << _val_2;
00162       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00163       T_return _retval;
00164       retmsg >> _retval;
00165       return _retval;
00166     }
00167 
00168     static pointer create(const std::string& name)
00169     { return pointer( new MethodProxy(name) ); }
00170 
00171   };
00172 
00173 
00180   template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00181   class MethodProxy <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00182     : public MethodProxyBase
00183   {
00184   public:
00185 
00186     typedef DBusCxxPointer<MethodProxy> pointer;
00187 
00188     MethodProxy(const std::string& name):
00189       MethodProxyBase(name)
00190     {  }
00191 
00192     T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3)
00193     {
00194       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::operator()   method=" << m_name );
00195       CallMessage::pointer _callmsg = this->create_call_message();
00196       *_callmsg  << _val_1 << _val_2 << _val_3;
00197       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00198       T_return _retval;
00199       retmsg >> _retval;
00200       return _retval;
00201     }
00202 
00203     static pointer create(const std::string& name)
00204     { return pointer( new MethodProxy(name) ); }
00205 
00206   };
00207 
00208 
00215   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00216   class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00217     : public MethodProxyBase
00218   {
00219   public:
00220 
00221     typedef DBusCxxPointer<MethodProxy> pointer;
00222 
00223     MethodProxy(const std::string& name):
00224       MethodProxyBase(name)
00225     {  }
00226 
00227     T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4)
00228     {
00229       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::operator()   method=" << m_name );
00230       CallMessage::pointer _callmsg = this->create_call_message();
00231       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4;
00232       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00233       T_return _retval;
00234       retmsg >> _retval;
00235       return _retval;
00236     }
00237 
00238     static pointer create(const std::string& name)
00239     { return pointer( new MethodProxy(name) ); }
00240 
00241   };
00242 
00243 
00250   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00251   class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00252     : public MethodProxyBase
00253   {
00254   public:
00255 
00256     typedef DBusCxxPointer<MethodProxy> pointer;
00257 
00258     MethodProxy(const std::string& name):
00259       MethodProxyBase(name)
00260     {  }
00261 
00262     T_return operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5)
00263     {
00264       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::operator()   method=" << m_name );
00265       CallMessage::pointer _callmsg = this->create_call_message();
00266       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4 << _val_5;
00267       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00268       T_return _retval;
00269       retmsg >> _retval;
00270       return _retval;
00271     }
00272 
00273     static pointer create(const std::string& name)
00274     { return pointer( new MethodProxy(name) ); }
00275 
00276   };
00277 
00278 
00285   template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00286   class MethodProxy <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00287     : public MethodProxyBase
00288   {
00289   public:
00290 
00291     typedef DBusCxxPointer<MethodProxy> pointer;
00292 
00293     MethodProxy(const std::string& name):
00294       MethodProxyBase(name)
00295     {  }
00296 
00297     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)
00298     {
00299       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::operator()   method=" << m_name );
00300       CallMessage::pointer _callmsg = this->create_call_message();
00301       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6;
00302       ReturnMessage::const_pointer retmsg = this->call( _callmsg );
00303       T_return _retval;
00304       retmsg >> _retval;
00305       return _retval;
00306     }
00307 
00308     static pointer create(const std::string& name)
00309     { return pointer( new MethodProxy(name) ); }
00310 
00311   };
00312 
00313 
00316   template <>
00317   class MethodProxy <void, nil,nil,nil,nil,nil,nil,nil>
00318     : public MethodProxyBase
00319   {
00320   public:
00321 
00322     typedef DBusCxxPointer<MethodProxy> pointer;
00323 
00324     MethodProxy(const std::string& name):
00325       MethodProxyBase(name)
00326     {  }
00327 
00328     void operator()()
00329     {
00330       DBUS_CXX_DEBUG("Method<T_return>::operator()   method=" << m_name );
00331       CallMessage::pointer _callmsg = this->create_call_message();
00332       *_callmsg ;
00333       _callmsg->set_no_reply();
00334       this->call( _callmsg );
00335     }
00336 
00337     static pointer create(const std::string& name)
00338     { return pointer( new MethodProxy(name) ); }
00339 
00340   };
00341 
00344   template <class T_arg1>
00345   class MethodProxy <void, T_arg1, nil,nil,nil,nil,nil,nil>
00346     : public MethodProxyBase
00347   {
00348   public:
00349 
00350     typedef DBusCxxPointer<MethodProxy> pointer;
00351 
00352     MethodProxy(const std::string& name):
00353       MethodProxyBase(name)
00354     {  }
00355 
00356     void operator()(T_arg1 _val_1)
00357     {
00358       DBUS_CXX_DEBUG("Method<T_return, T_arg1>::operator()   method=" << m_name );
00359       CallMessage::pointer _callmsg = this->create_call_message();
00360       *_callmsg  << _val_1;
00361       _callmsg->set_no_reply();
00362       this->call( _callmsg );
00363     }
00364 
00365     static pointer create(const std::string& name)
00366     { return pointer( new MethodProxy(name) ); }
00367 
00368   };
00369 
00372   template <class T_arg1,class T_arg2>
00373   class MethodProxy <void, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00374     : public MethodProxyBase
00375   {
00376   public:
00377 
00378     typedef DBusCxxPointer<MethodProxy> pointer;
00379 
00380     MethodProxy(const std::string& name):
00381       MethodProxyBase(name)
00382     {  }
00383 
00384     void operator()(T_arg1 _val_1,T_arg2 _val_2)
00385     {
00386       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2>::operator()   method=" << m_name );
00387       CallMessage::pointer _callmsg = this->create_call_message();
00388       *_callmsg  << _val_1 << _val_2;
00389       _callmsg->set_no_reply();
00390       this->call( _callmsg );
00391     }
00392 
00393     static pointer create(const std::string& name)
00394     { return pointer( new MethodProxy(name) ); }
00395 
00396   };
00397 
00400   template <class T_arg1,class T_arg2,class T_arg3>
00401   class MethodProxy <void, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00402     : public MethodProxyBase
00403   {
00404   public:
00405 
00406     typedef DBusCxxPointer<MethodProxy> pointer;
00407 
00408     MethodProxy(const std::string& name):
00409       MethodProxyBase(name)
00410     {  }
00411 
00412     void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3)
00413     {
00414       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3>::operator()   method=" << m_name );
00415       CallMessage::pointer _callmsg = this->create_call_message();
00416       *_callmsg  << _val_1 << _val_2 << _val_3;
00417       _callmsg->set_no_reply();
00418       this->call( _callmsg );
00419     }
00420 
00421     static pointer create(const std::string& name)
00422     { return pointer( new MethodProxy(name) ); }
00423 
00424   };
00425 
00428   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00429   class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
00430     : public MethodProxyBase
00431   {
00432   public:
00433 
00434     typedef DBusCxxPointer<MethodProxy> pointer;
00435 
00436     MethodProxy(const std::string& name):
00437       MethodProxyBase(name)
00438     {  }
00439 
00440     void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4)
00441     {
00442       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::operator()   method=" << m_name );
00443       CallMessage::pointer _callmsg = this->create_call_message();
00444       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4;
00445       _callmsg->set_no_reply();
00446       this->call( _callmsg );
00447     }
00448 
00449     static pointer create(const std::string& name)
00450     { return pointer( new MethodProxy(name) ); }
00451 
00452   };
00453 
00456   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00457   class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
00458     : public MethodProxyBase
00459   {
00460   public:
00461 
00462     typedef DBusCxxPointer<MethodProxy> pointer;
00463 
00464     MethodProxy(const std::string& name):
00465       MethodProxyBase(name)
00466     {  }
00467 
00468     void operator()(T_arg1 _val_1,T_arg2 _val_2,T_arg3 _val_3,T_arg4 _val_4,T_arg5 _val_5)
00469     {
00470       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::operator()   method=" << m_name );
00471       CallMessage::pointer _callmsg = this->create_call_message();
00472       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4 << _val_5;
00473       _callmsg->set_no_reply();
00474       this->call( _callmsg );
00475     }
00476 
00477     static pointer create(const std::string& name)
00478     { return pointer( new MethodProxy(name) ); }
00479 
00480   };
00481 
00484   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00485   class MethodProxy <void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
00486     : public MethodProxyBase
00487   {
00488   public:
00489 
00490     typedef DBusCxxPointer<MethodProxy> pointer;
00491 
00492     MethodProxy(const std::string& name):
00493       MethodProxyBase(name)
00494     {  }
00495 
00496     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)
00497     {
00498       DBUS_CXX_DEBUG("Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::operator()   method=" << m_name );
00499       CallMessage::pointer _callmsg = this->create_call_message();
00500       *_callmsg  << _val_1 << _val_2 << _val_3 << _val_4 << _val_5 << _val_6;
00501       _callmsg->set_no_reply();
00502       this->call( _callmsg );
00503     }
00504 
00505     static pointer create(const std::string& name)
00506     { return pointer( new MethodProxy(name) ); }
00507 
00508   };
00509 
00510 
00511 
00512 }
00513 
00514 #endif

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