dbus-cxx logo

interfaceproxy.h

Go to the documentation of this file.
00001 
00002 // -*- c++ -*-
00003 /* Do not edit! -- generated file */
00004 
00005 /***************************************************************************
00006  *   Copyright (C) 2007,2008,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 <sigc++/sigc++.h>
00024 
00025 #include <string>
00026 #include <map>
00027 #include <set>
00028 
00029 #include <dbus-cxx/methodproxy.h>
00030 #include <dbus-cxx/signal_proxy.h>
00031 
00032 #ifndef DBUSCXX_INTERFACEPROXY_H
00033 #define DBUSCXX_INTERFACEPROXY_H
00034 
00035 namespace DBus {
00036 
00037   class ObjectProxy;
00038 
00045   class InterfaceProxy
00046   {
00047     protected:
00048       InterfaceProxy(const std::string& name);
00049 
00050     public:
00051       typedef DBusCxxPointer<InterfaceProxy> pointer;
00052 
00053       typedef DBusCxxWeakPointer<InterfaceProxy> weak_pointer;
00054       
00055       typedef std::multimap<std::string, MethodProxyBase::pointer> Methods;
00056 
00057       typedef std::set<signal_proxy_base::pointer> Signals;
00058 
00059       static pointer create( const std::string& name = std::string() );
00060 
00061       virtual ~InterfaceProxy();
00062 
00063       ObjectProxy* object() const;
00064 
00065       Path path() const;
00066 
00067       DBusCxxPointer<Connection> connection() const;
00068 
00069       const std::string& name() const;
00070 
00071       void set_name( const std::string& new_name );
00072 
00073       const Methods& methods() const;
00074 
00076       MethodProxyBase::pointer method( const std::string& name ) const;
00077 
00078             template <class T_return>
00079       DBusCxxPointer<MethodProxy<T_return> > create_method( const std::string& name )
00080       {
00081         DBusCxxPointer< MethodProxy<T_return> > method;
00082         method = MethodProxy<T_return>::create(name);
00083         this->add_method(method);
00084         return method;
00085       }
00086       
00087                       template <class T_return, class T_arg1>
00088       DBusCxxPointer<MethodProxy<T_return, T_arg1> > create_method( const std::string& name )
00089       {
00090         DBusCxxPointer< MethodProxy<T_return, T_arg1> > method;
00091         method = MethodProxy<T_return, T_arg1>::create(name);
00092         this->add_method(method);
00093         return method;
00094       }
00095       
00096                       template <class T_return, class T_arg1,class T_arg2>
00097       DBusCxxPointer<MethodProxy<T_return, T_arg1,T_arg2> > create_method( const std::string& name )
00098       {
00099         DBusCxxPointer< MethodProxy<T_return, T_arg1,T_arg2> > method;
00100         method = MethodProxy<T_return, T_arg1,T_arg2>::create(name);
00101         this->add_method(method);
00102         return method;
00103       }
00104       
00105                       template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00106       DBusCxxPointer<MethodProxy<T_return, T_arg1,T_arg2,T_arg3> > create_method( const std::string& name )
00107       {
00108         DBusCxxPointer< MethodProxy<T_return, T_arg1,T_arg2,T_arg3> > method;
00109         method = MethodProxy<T_return, T_arg1,T_arg2,T_arg3>::create(name);
00110         this->add_method(method);
00111         return method;
00112       }
00113       
00114                       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00115       DBusCxxPointer<MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > create_method( const std::string& name )
00116       {
00117         DBusCxxPointer< MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > method;
00118         method = MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::create(name);
00119         this->add_method(method);
00120         return method;
00121       }
00122       
00123                       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00124       DBusCxxPointer<MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > create_method( const std::string& name )
00125       {
00126         DBusCxxPointer< MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > method;
00127         method = MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::create(name);
00128         this->add_method(method);
00129         return method;
00130       }
00131       
00132                       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00133       DBusCxxPointer<MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > create_method( const std::string& name )
00134       {
00135         DBusCxxPointer< MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > method;
00136         method = MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::create(name);
00137         this->add_method(method);
00138         return method;
00139       }
00140       
00141                       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>
00142       DBusCxxPointer<MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > create_method( const std::string& name )
00143       {
00144         DBusCxxPointer< MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > method;
00145         method = MethodProxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::create(name);
00146         this->add_method(method);
00147         return method;
00148       }
00149       
00150           
00151 
00153       bool add_method( MethodProxyBase::pointer method );
00154 
00156       void remove_method( const std::string& name );
00157 
00159       void remove_method( MethodProxyBase::pointer method );
00160 
00162       bool has_method( const std::string& name ) const;
00163 
00165       bool has_method( MethodProxyBase::pointer method ) const;
00166       
00167       CallMessage::pointer create_call_message( const std::string& method_name ) const;
00168 
00169       ReturnMessage::const_pointer call( CallMessage::const_pointer, int timeout_milliseconds=-1 ) const;
00170 
00171       PendingCall::pointer call_async( CallMessage::const_pointer, int timeout_milliseconds=-1 ) const;
00172 
00173             template <class T_return>
00174       DBusCxxPointer<signal_proxy<T_return> > create_signal( const std::string& sig_name )
00175       {
00176         DBusCxxPointer< signal_proxy<T_return> > sig;
00177         sig = signal_proxy<T_return>::create(this->path(), m_name, sig_name);
00178         this->add_signal(sig);
00179         return sig;
00180       }
00181       
00182                       template <class T_return, class T_arg1>
00183       DBusCxxPointer<signal_proxy<T_return, T_arg1> > create_signal( const std::string& sig_name )
00184       {
00185         DBusCxxPointer< signal_proxy<T_return, T_arg1> > sig;
00186         sig = signal_proxy<T_return, T_arg1>::create(this->path(), m_name, sig_name);
00187         this->add_signal(sig);
00188         return sig;
00189       }
00190       
00191                       template <class T_return, class T_arg1,class T_arg2>
00192       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2> > create_signal( const std::string& sig_name )
00193       {
00194         DBusCxxPointer< signal_proxy<T_return, T_arg1,T_arg2> > sig;
00195         sig = signal_proxy<T_return, T_arg1,T_arg2>::create(this->path(), m_name, sig_name);
00196         this->add_signal(sig);
00197         return sig;
00198       }
00199       
00200                       template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00201       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3> > create_signal( const std::string& sig_name )
00202       {
00203         DBusCxxPointer< signal_proxy<T_return, T_arg1,T_arg2,T_arg3> > sig;
00204         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3>::create(this->path(), m_name, sig_name);
00205         this->add_signal(sig);
00206         return sig;
00207       }
00208       
00209                       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00210       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > create_signal( const std::string& sig_name )
00211       {
00212         DBusCxxPointer< signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > sig;
00213         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::create(this->path(), m_name, sig_name);
00214         this->add_signal(sig);
00215         return sig;
00216       }
00217       
00218                       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00219       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > create_signal( const std::string& sig_name )
00220       {
00221         DBusCxxPointer< signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > sig;
00222         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::create(this->path(), m_name, sig_name);
00223         this->add_signal(sig);
00224         return sig;
00225       }
00226       
00227                       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00228       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > create_signal( const std::string& sig_name )
00229       {
00230         DBusCxxPointer< signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > sig;
00231         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::create(this->path(), m_name, sig_name);
00232         this->add_signal(sig);
00233         return sig;
00234       }
00235       
00236                       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>
00237       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > create_signal( const std::string& sig_name )
00238       {
00239         DBusCxxPointer< signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;
00240         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::create(this->path(), m_name, sig_name);
00241         this->add_signal(sig);
00242         return sig;
00243       }
00244       
00245                 
00246 
00247       const Signals& signals() const;
00248 
00249       signal_proxy_base::pointer signal( const std::string& signame );
00250 
00251       bool add_signal( signal_proxy_base::pointer sig );
00252 
00253       bool remove_signal( const std::string& signame );
00254 
00255       bool remove_signal( signal_proxy_base::pointer sig );
00256 
00257       bool has_signal( const std::string& signame ) const;
00258 
00259       bool has_signal( signal_proxy_base::pointer sig ) const;
00260 
00262       sigc::signal<void,const std::string&/*old name*/,const std::string&/*new name*/> signal_name_changed();
00263 
00265       sigc::signal<void,MethodProxyBase::pointer> signal_method_added();
00266 
00268       sigc::signal<void,MethodProxyBase::pointer> signal_method_removed();
00269 
00270     protected:
00271 
00272       friend class ObjectProxy;
00273       
00274       ObjectProxy* m_object;
00275       
00276       std::string m_name;
00277       
00278       Methods m_methods;
00279 
00280       Signals m_signals;
00281 
00282       mutable pthread_rwlock_t m_methods_rwlock;
00283 
00285       pthread_mutex_t m_name_mutex;
00286 
00287       sigc::signal<void,const std::string&,const std::string&> m_signal_name_changed;
00288       
00289       sigc::signal<void,MethodProxyBase::pointer> m_signal_method_added;
00290       
00291       sigc::signal<void,MethodProxyBase::pointer> m_signal_method_removed;
00292 
00293       typedef std::map<MethodProxyBase::pointer,sigc::connection> MethodSignalNameConnections;
00294 
00295       MethodSignalNameConnections m_method_signal_name_connections;
00296 
00297       void on_method_name_changed(const std::string& oldname, const std::string& newname, MethodProxyBase::pointer method);
00298 
00299       void on_object_set_connection( DBusCxxPointer<Connection> conn );
00300 
00301       void on_object_set_path( const std::string& path );
00302   };
00303 
00304 }
00305 
00306 #endif
00307 

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