dbus-cxx logo

connection.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 <list>
00024 #include <deque>
00025 
00026 #include <dbus-cxx/pointer.h>
00027 #include <dbus-cxx/message.h>
00028 #include <dbus-cxx/returnmessage.h>
00029 #include <dbus-cxx/pendingcall.h>
00030 #include <dbus-cxx/watch.h>
00031 #include <dbus-cxx/timeout.h>
00032 #include <dbus-cxx/accumulators.h>
00033 #include <dbus-cxx/object.h>
00034 #include <dbus-cxx/objectproxy.h>
00035 #include <dbus-cxx/signal_proxy.h>
00036 #include <dbus-cxx/dbus_signal.h>
00037 #include <dbus-cxx/messagefilter.h>
00038 #include <dbus-cxx/method.h>
00039 
00040 #include <iostream>
00041 
00042 #ifndef DBUSCXX_CONNECTION_H
00043 #define DBUSCXX_CONNECTION_H
00044 
00045 namespace DBus
00046 {
00047 
00048   class Object;
00049   class signal_base;
00050   class PendingCall;
00051 
00061   class Connection
00062   {
00063     
00064     protected:
00065     
00066       // TODO dbus_connection_open
00067 
00068       Connection( DBusConnection* cobj = NULL, bool is_private=false );
00069 
00075       Connection( BusType type, bool is_private=false );
00076 
00077       Connection( const Connection& other );
00078 
00079     public:
00080       
00081       typedef DBusCxxPointer<Connection> pointer;
00082       
00083       typedef DBusCxxWeakPointer<Connection> weak_pointer;
00084 
00085       // TODO dbus_connection_open
00086 
00087       static pointer create( DBusConnection* cobj = NULL, bool is_private=false );
00088 
00094       static pointer create( BusType type, bool is_private=false );
00095 
00096       static pointer create( const Connection& other );
00097 
00098       virtual ~Connection();
00099 
00101       operator bool() const;
00102 
00104       bool is_valid() const;
00105 
00107       bool is_private() const;
00108 
00110       bool bus_register();
00111 
00113       bool is_registered() const;
00114 
00116       const char* unique_name() const;
00117 
00118       // TODO set_unique_name() 
00119 
00124       unsigned long unix_user( const std::string& name ) const;
00125 
00127       const char* bus_id() const;
00128 
00129       int request_name( const std::string& name, unsigned int flags = 0 );
00130 
00131       int release_name( const std::string& name );
00132 
00133       bool name_has_owner( const std::string& name ) const;
00134 
00135       StartReply start_service( const std::string& name, uint32_t flags ) const;
00136 
00137       bool add_match( const std::string& rule );
00138 
00139       void add_match_nonblocking( const std::string& rule );
00140 
00141       bool remove_match( const std::string& rule );
00142 
00143       void remove_match_nonblocking( const std::string& rule );
00144 
00145       // TODO dbus_connection_close 
00146 
00147       bool is_connected() const;
00148 
00149       bool is_authenticated() const;
00150 
00151       bool is_anonymous() const;
00152 
00153       const char* server_id() const;
00154 
00155       // TODO dbus_connection_preallocate_send
00156       // TODO dbus_connection_free_preallocated_send
00157       // TODO dbus_connection_send_preallocated
00158 
00159       uint32_t send( const Message::const_pointer );
00160 
00164       Connection& operator<<( Message::const_pointer msg );
00165 
00166       PendingCall::pointer send_with_reply_async( Message::const_pointer message, int timeout_milliseconds=-1 ) const;
00167 
00168       ReturnMessage::const_pointer send_with_reply_blocking( Message::const_pointer msg, int timeout_milliseconds=-1 ) const;
00169 
00170       void flush();
00171 
00172       bool read_write_dispatch( int timeout_milliseconds=-1 );
00173 
00174       bool read_write( int timeout_milliseconds=-1 );
00175 
00176       Message::pointer borrow_message();
00177 
00178       void return_message( Message::pointer message );
00179 
00180       void steal_borrowed_message( Message::pointer message );
00181 
00182       Message::pointer pop_message( );
00183 
00184       DispatchStatus dispatch_status( ) const;
00185 
00186       DispatchStatus dispatch( );
00187 
00188       int unix_fd() const;
00189 
00190       int socket() const;
00191 
00192       unsigned long unix_user() const;
00193 
00194       unsigned long unix_process_id() const;
00195 
00196       // TODO dbus_connection_get_adt_audit_session_data
00197 
00198       // TODO dbus_connection_set_unix_user_function
00199 
00200       // TODO dbus_connection_get_windows_user
00201 
00202       // TODO dbus_connection_set_windows_user_function
00203 
00204       void set_allow_anonymous( bool allow=true );
00205 
00206       void set_route_peer_messages( bool route=true );
00207 
00208       // TODO dbus_connection_try_register_object_path
00209       // TODO dbus_connection_register_object_path
00210       // TODO dbus_connection_try_register_fallback
00211       // TODO dbus_connection_register_fallback
00212       // TODO dbus_connection_unregister_object_path
00213       // TODO dbus_connection_get_object_path_data
00214       // TODO dbus_connection_list_registered
00215 
00216       void set_max_message_size( long size );
00217 
00218       long max_message_size();
00219 
00220       void set_max_received_size( long size );
00221 
00222       long max_received_size();
00223 
00224       long outgoing_size();
00225 
00226       bool has_messages_to_send();
00227 
00228       typedef sigc::signal1<bool,Watch::pointer,InterruptablePredicateAccumulatorDefaultFalse> AddWatchSignal;
00229 
00231       AddWatchSignal& signal_add_watch();
00232 
00233       sigc::signal<bool,Watch::pointer>& signal_remove_watch();
00234 
00235       sigc::signal<bool,Watch::pointer>& signal_watch_toggled();
00236 
00237       typedef sigc::signal1<bool,Timeout::pointer,InterruptablePredicateAccumulatorDefaultFalse> AddTimeoutSignal;
00238       
00240       AddTimeoutSignal& signal_add_timeout();
00241 
00242       sigc::signal<bool,Timeout::pointer>& signal_remove_timeout();
00243 
00244       sigc::signal<bool,Timeout::pointer>& signal_timeout_toggled();
00245 
00246       sigc::signal<void>& signal_wakeup_main();
00247 
00249       sigc::signal<void,DispatchStatus>& signal_dispatch_status_changed();
00250 
00255       FilterSignal& signal_filter();
00256 
00257       typedef std::deque<Watch::pointer> Watches;
00258       
00259       const Watches& unhandled_watches() const;
00260       
00261       void remove_unhandled_watch(const Watch::pointer w);
00262 
00263       Object::pointer create_object( const std::string& path, PrimaryFallback pf=PRIMARY );
00264 
00265       bool register_object( Object::pointer object );
00266 
00267       ObjectPathHandler::pointer create_object( const std::string& path, sigc::slot<HandlerResult,Connection::pointer,Message::const_pointer>& slot, PrimaryFallback pf=PRIMARY );
00268 
00269       ObjectPathHandler::pointer create_object( const std::string& path, HandlerResult (*MessageFunction)(Connection::pointer,Message::const_pointer), PrimaryFallback pf=PRIMARY );
00270 
00271       ObjectProxy::pointer create_object_proxy( const std::string& path );
00272 
00273       ObjectProxy::pointer create_object_proxy( const std::string& destination, const std::string& path );
00274 
00275       bool unregister_object( const std::string& path );
00276 
00282       signal_proxy_simple::pointer create_signal_proxy( const std::string& interface, const std::string& name );
00283 
00289       signal_proxy_simple::pointer create_signal_proxy( const std::string& path, const std::string& interface, const std::string& name );
00290 
00291       template <class T_return>
00292       DBusCxxPointer<signal_proxy<T_return> > create_signal_proxy( const std::string& interface, const std::string& name )
00293       {
00294         DBusCxxPointer<signal_proxy<T_return> > sig;
00295         sig = signal_proxy<T_return>::create(interface, name);
00296         this->add_signal_proxy( sig );
00297         return sig;
00298       }
00299       
00300       template <class T_return, class T_arg1>
00301       DBusCxxPointer<signal_proxy<T_return, T_arg1> > create_signal_proxy( const std::string& interface, const std::string& name )
00302       {
00303         DBusCxxPointer<signal_proxy<T_return, T_arg1> > sig;
00304         sig = signal_proxy<T_return, T_arg1>::create(interface, name);
00305         this->add_signal_proxy( sig );
00306         return sig;
00307       }
00308       
00309       template <class T_return, class T_arg1,class T_arg2>
00310       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2> > create_signal_proxy( const std::string& interface, const std::string& name )
00311       {
00312         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2> > sig;
00313         sig = signal_proxy<T_return, T_arg1,T_arg2>::create(interface, name);
00314         this->add_signal_proxy( sig );
00315         return sig;
00316       }
00317       
00318       template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00319       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3> > create_signal_proxy( const std::string& interface, const std::string& name )
00320       {
00321         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3> > sig;
00322         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3>::create(interface, name);
00323         this->add_signal_proxy( sig );
00324         return sig;
00325       }
00326       
00327       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00328       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > create_signal_proxy( const std::string& interface, const std::string& name )
00329       {
00330         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > sig;
00331         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::create(interface, name);
00332         this->add_signal_proxy( sig );
00333         return sig;
00334       }
00335       
00336       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00337       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > create_signal_proxy( const std::string& interface, const std::string& name )
00338       {
00339         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > sig;
00340         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::create(interface, name);
00341         this->add_signal_proxy( sig );
00342         return sig;
00343       }
00344       
00345       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00346       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > create_signal_proxy( const std::string& interface, const std::string& name )
00347       {
00348         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > sig;
00349         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::create(interface, name);
00350         this->add_signal_proxy( sig );
00351         return sig;
00352       }
00353       
00354       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>
00355       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > create_signal_proxy( const std::string& interface, const std::string& name )
00356       {
00357         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;
00358         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::create(interface, name);
00359         this->add_signal_proxy( sig );
00360         return sig;
00361       }
00362       
00363 
00364       
00365       template <class T_return>
00366       DBusCxxPointer<signal_proxy<T_return> > create_signal_proxy( const std::string& path, const std::string& interface, const std::string& name )
00367       {
00368         DBusCxxPointer<signal_proxy<T_return> > sig;
00369         sig = signal_proxy<T_return>::create(path, interface, name);
00370         this->add_signal_proxy( sig );
00371         return sig;
00372       }
00373       
00374       template <class T_return, class T_arg1>
00375       DBusCxxPointer<signal_proxy<T_return, T_arg1> > create_signal_proxy( const std::string& path, const std::string& interface, const std::string& name )
00376       {
00377         DBusCxxPointer<signal_proxy<T_return, T_arg1> > sig;
00378         sig = signal_proxy<T_return, T_arg1>::create(path, interface, name);
00379         this->add_signal_proxy( sig );
00380         return sig;
00381       }
00382       
00383       template <class T_return, class T_arg1,class T_arg2>
00384       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2> > create_signal_proxy( const std::string& path, const std::string& interface, const std::string& name )
00385       {
00386         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2> > sig;
00387         sig = signal_proxy<T_return, T_arg1,T_arg2>::create(path, interface, name);
00388         this->add_signal_proxy( sig );
00389         return sig;
00390       }
00391       
00392       template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00393       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3> > create_signal_proxy( const std::string& path, const std::string& interface, const std::string& name )
00394       {
00395         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3> > sig;
00396         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3>::create(path, interface, name);
00397         this->add_signal_proxy( sig );
00398         return sig;
00399       }
00400       
00401       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00402       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > create_signal_proxy( const std::string& path, const std::string& interface, const std::string& name )
00403       {
00404         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > sig;
00405         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::create(path, interface, name);
00406         this->add_signal_proxy( sig );
00407         return sig;
00408       }
00409       
00410       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00411       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > create_signal_proxy( const std::string& path, const std::string& interface, const std::string& name )
00412       {
00413         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > sig;
00414         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::create(path, interface, name);
00415         this->add_signal_proxy( sig );
00416         return sig;
00417       }
00418       
00419       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00420       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > create_signal_proxy( const std::string& path, const std::string& interface, const std::string& name )
00421       {
00422         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > sig;
00423         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::create(path, interface, name);
00424         this->add_signal_proxy( sig );
00425         return sig;
00426       }
00427       
00428       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>
00429       DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > create_signal_proxy( const std::string& path, const std::string& interface, const std::string& name )
00430       {
00431         DBusCxxPointer<signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;
00432         sig = signal_proxy<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::create(path, interface, name);
00433         this->add_signal_proxy( sig );
00434         return sig;
00435       }
00436       
00437 
00438 
00442       signal_proxy_base::pointer add_signal_proxy( signal_proxy_base::pointer signal );
00443 
00444       bool remove_signal_proxy( signal_proxy_base::pointer proxy );
00445 
00446       typedef std::list<signal_proxy_base::pointer> ProxySignals;
00447       
00448       typedef std::map<std::string,ProxySignals> NameToProxySignalMap;
00449 
00450       typedef std::map<std::string,NameToProxySignalMap> InterfaceToNameProxySignalMap;
00451 
00453       const InterfaceToNameProxySignalMap& get_signal_proxies();
00454 
00456       NameToProxySignalMap get_signal_proxies( const std::string& interface );
00457 
00459       ProxySignals get_signal_proxies( const std::string& interface, const std::string& member );
00460 
00461       template <class T_return>
00462       DBusCxxPointer<signal<T_return> > create_signal( const std::string& interface, const std::string& name )
00463       {
00464         DBusCxxPointer<signal<T_return> > sig;
00465         sig = signal<T_return>::create(interface, name);
00466         sig->set_connection(this->self());
00467         return sig;
00468       }
00469       
00470       template <class T_return, class T_arg1>
00471       DBusCxxPointer<signal<T_return, T_arg1> > create_signal( const std::string& interface, const std::string& name )
00472       {
00473         DBusCxxPointer<signal<T_return, T_arg1> > sig;
00474         sig = signal<T_return, T_arg1>::create(interface, name);
00475         sig->set_connection(this->self());
00476         return sig;
00477       }
00478       
00479       template <class T_return, class T_arg1,class T_arg2>
00480       DBusCxxPointer<signal<T_return, T_arg1,T_arg2> > create_signal( const std::string& interface, const std::string& name )
00481       {
00482         DBusCxxPointer<signal<T_return, T_arg1,T_arg2> > sig;
00483         sig = signal<T_return, T_arg1,T_arg2>::create(interface, name);
00484         sig->set_connection(this->self());
00485         return sig;
00486       }
00487       
00488       template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00489       DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3> > create_signal( const std::string& interface, const std::string& name )
00490       {
00491         DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3> > sig;
00492         sig = signal<T_return, T_arg1,T_arg2,T_arg3>::create(interface, name);
00493         sig->set_connection(this->self());
00494         return sig;
00495       }
00496       
00497       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00498       DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > create_signal( const std::string& interface, const std::string& name )
00499       {
00500         DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > sig;
00501         sig = signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::create(interface, name);
00502         sig->set_connection(this->self());
00503         return sig;
00504       }
00505       
00506       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00507       DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > create_signal( const std::string& interface, const std::string& name )
00508       {
00509         DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > sig;
00510         sig = signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::create(interface, name);
00511         sig->set_connection(this->self());
00512         return sig;
00513       }
00514       
00515       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00516       DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > create_signal( const std::string& interface, const std::string& name )
00517       {
00518         DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > sig;
00519         sig = signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::create(interface, name);
00520         sig->set_connection(this->self());
00521         return sig;
00522       }
00523       
00524       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>
00525       DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > create_signal( const std::string& interface, const std::string& name )
00526       {
00527         DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;
00528         sig = signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::create(interface, name);
00529         sig->set_connection(this->self());
00530         return sig;
00531       }
00532       
00533 
00534       
00535       template <class T_return>
00536       DBusCxxPointer<signal<T_return> > create_signal( const std::string& path, const std::string& interface, const std::string& name )
00537       {
00538         DBusCxxPointer<signal<T_return> > sig;
00539         sig = signal<T_return>::create(path, interface, name);
00540         sig->set_connection(this->self());
00541         return sig;
00542       }
00543       
00544       template <class T_return, class T_arg1>
00545       DBusCxxPointer<signal<T_return, T_arg1> > create_signal( const std::string& path, const std::string& interface, const std::string& name )
00546       {
00547         DBusCxxPointer<signal<T_return, T_arg1> > sig;
00548         sig = signal<T_return, T_arg1>::create(path, interface, name);
00549         sig->set_connection(this->self());
00550         return sig;
00551       }
00552       
00553       template <class T_return, class T_arg1,class T_arg2>
00554       DBusCxxPointer<signal<T_return, T_arg1,T_arg2> > create_signal( const std::string& path, const std::string& interface, const std::string& name )
00555       {
00556         DBusCxxPointer<signal<T_return, T_arg1,T_arg2> > sig;
00557         sig = signal<T_return, T_arg1,T_arg2>::create(path, interface, name);
00558         sig->set_connection(this->self());
00559         return sig;
00560       }
00561       
00562       template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00563       DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3> > create_signal( const std::string& path, const std::string& interface, const std::string& name )
00564       {
00565         DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3> > sig;
00566         sig = signal<T_return, T_arg1,T_arg2,T_arg3>::create(path, interface, name);
00567         sig->set_connection(this->self());
00568         return sig;
00569       }
00570       
00571       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
00572       DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > create_signal( const std::string& path, const std::string& interface, const std::string& name )
00573       {
00574         DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > sig;
00575         sig = signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>::create(path, interface, name);
00576         sig->set_connection(this->self());
00577         return sig;
00578       }
00579       
00580       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
00581       DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > create_signal( const std::string& path, const std::string& interface, const std::string& name )
00582       {
00583         DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > sig;
00584         sig = signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::create(path, interface, name);
00585         sig->set_connection(this->self());
00586         return sig;
00587       }
00588       
00589       template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
00590       DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > create_signal( const std::string& path, const std::string& interface, const std::string& name )
00591       {
00592         DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > sig;
00593         sig = signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::create(path, interface, name);
00594         sig->set_connection(this->self());
00595         return sig;
00596       }
00597       
00598       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>
00599       DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > create_signal( const std::string& path, const std::string& interface, const std::string& name )
00600       {
00601         DBusCxxPointer<signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;
00602         sig = signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::create(path, interface, name);
00603         sig->set_connection(this->self());
00604         return sig;
00605       }
00606       
00607 
00608 
00609       //       bool register_object( Object& obj, const std::string & path );
00610 //
00611 //       bool register_signal( signal_base& );
00612 
00614       pointer self();
00615 
00630       static pointer self(DBusConnection* c);
00631       
00632       DBusConnection* cobj();
00633 
00634       static void set_global_change_sigpipe(bool will_modify_sigpipe=true);
00635 
00636       std::string introspect( const std::string& destination, const std::string& path );
00637 
00638     protected:
00639       DBusConnection* m_cobj;
00640       
00641       bool m_private_flag;
00642       
00643       AddWatchSignal m_add_watch_signal;
00644       
00645       sigc::signal<bool,Watch::pointer> m_remove_watch_signal;
00646       
00647       sigc::signal<bool,Watch::pointer> m_watch_toggled_signal;
00648       
00649       AddTimeoutSignal m_add_timeout_signal;
00650       
00651       sigc::signal<bool,Timeout::pointer> m_remove_timeout_signal;
00652       
00653       sigc::signal<bool,Timeout::pointer> m_timeout_toggled_signal;
00654       
00655       sigc::signal<void> m_wakeup_main_signal;
00656       
00657       sigc::signal<void,DispatchStatus> m_dispatch_status_signal;
00658       
00659       FilterSignal m_filter_signal;
00660       
00661       Watches m_unhandled_watches;
00662       
00663       typedef std::map<DBusTimeout*,Timeout::pointer> Timeouts;
00664 
00665       Timeouts m_timeouts;
00666 
00667       friend void init(bool);
00668 
00669       static dbus_int32_t m_weak_pointer_slot;
00670 
00671       void initialize( bool is_private );
00672 
00673       std::map<std::string,ObjectPathHandler::pointer> m_created_objects;
00674 
00675       InterfaceToNameProxySignalMap m_proxy_signal_interface_map;
00676 
00677 //       std::map<SignalReceiver::pointer, sigc::connection> m_sighandler_iface_conn;
00678 
00679 //       std::map<SignalReceiver::pointer, sigc::connection> m_sighandler_member_conn;
00680 
00681 //       void on_signal_handler_interface_changed(SignalReceiver::pointer handler);
00682 
00683 //       void on_signal_handler_member_changed(SignalReceiver::pointer handler);
00684 
00685 //       typedef std::map<std::string,signal_base> SignalVTable;
00686 //
00687 //       typedef std::map<std::string, SignalVTable> InterfaceVTable;
00688 
00689       static dbus_bool_t on_add_watch_callback( DBusWatch* cwatch, void* data );
00690 
00691       static void on_remove_watch_callback( DBusWatch* cwatch, void* data );
00692 
00693       static void on_watch_toggled_callback( DBusWatch* cwatch, void* data );
00694 
00695       static dbus_bool_t on_add_timeout_callback( DBusTimeout* ctimeout, void* data );
00696 
00697       static void on_remove_timeout_callback( DBusTimeout* ctimeout, void* data );
00698 
00699       static void on_timeout_toggled_callback( DBusTimeout* ctimeout, void* data );
00700 
00701       static void on_wakeup_main_callback( void* data );
00702 
00703       static void on_dispatch_status_callback( DBusConnection* connection, DBusDispatchStatus new_status, void* data );
00704 
00705       static DBusHandlerResult on_filter_callback( DBusConnection* connection, DBusMessage* message, void* data );
00706 
00707   };
00708   
00709 }
00710 
00711 inline
00712 DBus::Connection::pointer operator<<(DBus::Connection::pointer ptr, DBus::Message::pointer msg)
00713 {
00714   if (not ptr) return ptr;
00715   *ptr << msg;
00716   return ptr;
00717 }
00718 
00719 inline
00720 DBus::Connection::pointer operator<<(DBus::Connection::pointer ptr, DBus::Message::const_pointer msg)
00721 {
00722   if (not ptr) return ptr;
00723   *ptr << msg;
00724   return ptr;
00725 }
00726 
00727 inline
00728 DBus::Connection::pointer operator<<(DBus::Connection::pointer ptr, DBus::ReturnMessage::pointer msg)
00729 {
00730   if (not ptr) return ptr;
00731   *ptr << msg;
00732   return ptr;
00733 }
00734 
00735 inline
00736 DBus::Connection::pointer operator<<(DBus::Connection::pointer ptr, DBus::ReturnMessage::const_pointer msg)
00737 {
00738   if (not ptr) return ptr;
00739   *ptr << msg;
00740   return ptr;
00741 }
00742 
00743 inline
00744 DBus::Connection::pointer operator<<(DBus::Connection::pointer ptr, DBus::SignalMessage::pointer msg)
00745 {
00746   if (not ptr) return ptr;
00747   *ptr << msg;
00748   return ptr;
00749 }
00750 
00751 inline
00752 DBus::Connection::pointer operator<<(DBus::Connection::pointer ptr, DBus::SignalMessage::const_pointer msg)
00753 {
00754   if (not ptr) return ptr;
00755   *ptr << msg;
00756   return ptr;
00757 }
00758 
00759 #endif
00760 
00761 // #include <dbus-cxx/method_impl.h>

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