dbus-cxx logo

connection.h

Go to the documentation of this file.
00001 /***************************************************************************
00002  *   Copyright (C) 2007,2008,2009 by Rick L. Vinyard, Jr.                  *
00003  *   rvinyard@cs.nmsu.edu                                                  *
00004  *                                                                         *
00005  *   This file is part of the dbus-cxx library.                            *
00006  *                                                                         *
00007  *   The dbus-cxx library is free software; you can redistribute it and/or *
00008  *   modify it under the terms of the GNU General Public License           *
00009  *   version 3 as published by the Free Software Foundation.               *
00010  *                                                                         *
00011  *   The dbus-cxx library is distributed in the hope that it will be       *
00012  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty   *
00013  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   *
00014  *   General Public License for more details.                              *
00015  *                                                                         *
00016  *   You should have received a copy of the GNU General Public License     *
00017  *   along with this software. If not see <http://www.gnu.org/licenses/>.  *
00018  ***************************************************************************/
00019 #ifndef __DBUSXX_CONNECTION_H
00020 #define __DBUSXX_CONNECTION_H
00021 
00022 #include <list>
00023 #include <deque>
00024 
00025 #include <dbus-cxx/pointer.h>
00026 #include <dbus-cxx/message.h>
00027 #include <dbus-cxx/returnmessage.h>
00028 #include <dbus-cxx/pendingcall.h>
00029 #include <dbus-cxx/watch.h>
00030 #include <dbus-cxx/timeout.h>
00031 #include <dbus-cxx/accumulators.h>
00032 #include <dbus-cxx/object.h>
00033 #include <dbus-cxx/objectproxy.h>
00034 #include <dbus-cxx/signal_proxy.h>
00035 #include <dbus-cxx/dbus_signal.h>
00036 #include <dbus-cxx/messagefilter.h>
00037 #include <dbus-cxx/method.h>
00038 
00039 #include <iostream>
00040 
00041 namespace DBus
00042 {
00043 
00044   class Object;
00045   class signal_base;
00046   class PendingCall;
00047 
00057   class Connection
00058   {
00059     
00060     protected:
00061     
00062       // TODO dbus_connection_open
00063 
00064       Connection( DBusConnection* cobj = NULL, bool is_private=false );
00065 
00071       Connection( BusType type, bool is_private=false );
00072 
00073       Connection( const Connection& other );
00074 
00075     public:
00076       
00077       typedef DBusCxxPointer<Connection> pointer;
00078       
00079       typedef DBusCxxWeakPointer<Connection> weak_pointer;
00080 
00081       // TODO dbus_connection_open
00082 
00083       static pointer create( DBusConnection* cobj = NULL, bool is_private=false );
00084 
00090       static pointer create( BusType type, bool is_private=false );
00091 
00092       static pointer create( const Connection& other );
00093 
00094       virtual ~Connection();
00095 
00097       operator bool() const;
00098 
00100       bool is_valid() const;
00101 
00103       bool is_private() const;
00104 
00106       bool bus_register();
00107 
00109       bool is_registered() const;
00110 
00112       const char* unique_name() const;
00113 
00114       // TODO set_unique_name() 
00115 
00120       unsigned long unix_user( const std::string& name ) const;
00121 
00123       const char* bus_id() const;
00124 
00125       int request_name( const std::string& name, unsigned int flags = 0 );
00126 
00127       int release_name( const std::string& name );
00128 
00129       bool name_has_owner( const std::string& name ) const;
00130 
00131       StartReply start_service( const std::string& name, uint32_t flags ) const;
00132 
00133       bool add_match( const std::string& rule );
00134 
00135       void add_match_nonblocking( const std::string& rule );
00136 
00137       bool remove_match( const std::string& rule );
00138 
00139       void remove_match_nonblocking( const std::string& rule );
00140 
00141       // TODO dbus_connection_close 
00142 
00143       bool is_connected() const;
00144 
00145       bool is_authenticated() const;
00146 
00147       bool is_anonymous() const;
00148 
00149       const char* server_id() const;
00150 
00151       // TODO dbus_connection_preallocate_send
00152       // TODO dbus_connection_free_preallocated_send
00153       // TODO dbus_connection_send_preallocated
00154 
00155       uint32_t send( const Message::const_pointer );
00156 
00160       Connection& operator<<( Message::const_pointer msg );
00161 
00162       PendingCall::pointer send_with_reply_async( Message::const_pointer message, int timeout_milliseconds=-1 ) const;
00163 
00164       ReturnMessage::const_pointer send_with_reply_blocking( Message::const_pointer msg, int timeout_milliseconds=-1 ) const;
00165 
00166       void flush();
00167 
00168       bool read_write_dispatch( int timeout_milliseconds=-1 );
00169 
00170       bool read_write( int timeout_milliseconds=-1 );
00171 
00172       Message::pointer borrow_message();
00173 
00174       void return_message( Message::pointer message );
00175 
00176       void steal_borrowed_message( Message::pointer message );
00177 
00178       Message::pointer pop_message( );
00179 
00180       DispatchStatus dispatch_status( ) const;
00181 
00182       DispatchStatus dispatch( );
00183 
00184       int unix_fd() const;
00185 
00186       int socket() const;
00187 
00188       unsigned long unix_user() const;
00189 
00190       unsigned long unix_process_id() const;
00191 
00192       // TODO dbus_connection_get_adt_audit_session_data
00193 
00194       // TODO dbus_connection_set_unix_user_function
00195 
00196       // TODO dbus_connection_get_windows_user
00197 
00198       // TODO dbus_connection_set_windows_user_function
00199 
00200       void set_allow_anonymous( bool allow=true );
00201 
00202       void set_route_peer_messages( bool route=true );
00203 
00204       // TODO dbus_connection_try_register_object_path
00205       // TODO dbus_connection_register_object_path
00206       // TODO dbus_connection_try_register_fallback
00207       // TODO dbus_connection_register_fallback
00208       // TODO dbus_connection_unregister_object_path
00209       // TODO dbus_connection_get_object_path_data
00210       // TODO dbus_connection_list_registered
00211 
00212       void set_max_message_size( long size );
00213 
00214       long max_message_size();
00215 
00216       void set_max_received_size( long size );
00217 
00218       long max_received_size();
00219 
00220       long outgoing_size();
00221 
00222       bool has_messages_to_send();
00223 
00224       typedef sigc::signal1<bool,Watch::pointer,InterruptablePredicateAccumulatorDefaultFalse> AddWatchSignal;
00225 
00227       AddWatchSignal& signal_add_watch();
00228 
00229       sigc::signal<bool,Watch::pointer>& signal_remove_watch();
00230 
00231       sigc::signal<bool,Watch::pointer>& signal_watch_toggled();
00232 
00233       typedef sigc::signal1<bool,Timeout::pointer,InterruptablePredicateAccumulatorDefaultFalse> AddTimeoutSignal;
00234       
00236       AddTimeoutSignal& signal_add_timeout();
00237 
00238       sigc::signal<bool,Timeout::pointer>& signal_remove_timeout();
00239 
00240       sigc::signal<bool,Timeout::pointer>& signal_timeout_toggled();
00241 
00242       sigc::signal<void>& signal_wakeup_main();
00243 
00245       sigc::signal<void,DispatchStatus>& signal_dispatch_status_changed();
00246 
00251       FilterSignal& signal_filter();
00252 
00253       typedef std::deque<Watch::pointer> Watches;
00254       
00255       const Watches& unhandled_watches() const;
00256       
00257       void remove_unhandled_watch(const Watch::pointer w);
00258 
00259       Object::pointer create_object( const std::string& path, PrimaryFallback pf=PRIMARY );
00260 
00261       bool register_object( Object::pointer object );
00262 
00263       ObjectPathHandler::pointer create_object( const std::string& path, sigc::slot<HandlerResult,Connection::pointer,Message::const_pointer>& slot, PrimaryFallback pf=PRIMARY );
00264 
00265       ObjectPathHandler::pointer create_object( const std::string& path, HandlerResult (*MessageFunction)(Connection::pointer,Message::const_pointer), PrimaryFallback pf=PRIMARY );
00266 
00267       ObjectProxy::pointer create_object_proxy( const std::string& path );
00268 
00269       ObjectProxy::pointer create_object_proxy( const std::string& destination, const std::string& path );
00270 
00271       bool unregister_object( const std::string& path );
00272 
00278       signal_proxy_simple::pointer create_signal_proxy( const std::string& interface, const std::string& name );
00279 
00285       signal_proxy_simple::pointer create_signal_proxy( const std::string& path, const std::string& interface, const std::string& name );
00286 
00287       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>
00288       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 ) {
00289 //         signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> sig;
00290         DBusCxxPointer<signal_proxy<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;
00291         sig = signal_proxy<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::create(interface, name);
00292         this->add_signal_proxy(sig);
00293         return sig;
00294       }
00295 
00296       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>
00297       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 ) {
00298 //         signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> sig;
00299         DBusCxxPointer<signal_proxy<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;
00300         sig = signal_proxy<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::create(path, interface, name);
00301         this->add_signal_proxy(sig);
00302         return sig;
00303       }
00304 
00308       signal_proxy_base::pointer add_signal_proxy( signal_proxy_base::pointer signal );
00309 
00310       bool remove_signal_proxy( signal_proxy_base::pointer proxy );
00311 
00312       typedef std::list<signal_proxy_base::pointer> ProxySignals;
00313       
00314       typedef std::map<std::string,ProxySignals> NameToProxySignalMap;
00315 
00316       typedef std::map<std::string,NameToProxySignalMap> InterfaceToNameProxySignalMap;
00317 
00319       const InterfaceToNameProxySignalMap& get_signal_proxies();
00320 
00322       NameToProxySignalMap get_signal_proxies( const std::string& interface );
00323 
00325       ProxySignals get_signal_proxies( const std::string& interface, const std::string& member );
00326 
00327       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>
00328       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 ) {
00329         DBusCxxPointer<signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;
00330         sig = signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::create(interface, name);
00331         sig->m_connection = this->self();
00332         return sig;
00333       }
00334 
00335       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>
00336       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 ) {
00337         DBusCxxPointer<signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;
00338         sig = signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::create(path, interface, name);
00339         sig->set_connection(this->self());
00340         return sig;
00341       }
00342 
00343       //       bool register_object( Object& obj, const std::string & path );
00344 //
00345 //       bool register_signal( signal_base& );
00346 
00348       pointer self();
00349 
00364       static pointer self(DBusConnection* c);
00365       
00366       DBusConnection* cobj();
00367 
00368       static void set_global_change_sigpipe(bool will_modify_sigpipe=true);
00369 
00370     protected:
00371       DBusConnection* m_cobj;
00372       
00373       bool m_private_flag;
00374       
00375       AddWatchSignal m_add_watch_signal;
00376       
00377       sigc::signal<bool,Watch::pointer> m_remove_watch_signal;
00378       
00379       sigc::signal<bool,Watch::pointer> m_watch_toggled_signal;
00380       
00381       AddTimeoutSignal m_add_timeout_signal;
00382       
00383       sigc::signal<bool,Timeout::pointer> m_remove_timeout_signal;
00384       
00385       sigc::signal<bool,Timeout::pointer> m_timeout_toggled_signal;
00386       
00387       sigc::signal<void> m_wakeup_main_signal;
00388       
00389       sigc::signal<void,DispatchStatus> m_dispatch_status_signal;
00390       
00391       FilterSignal m_filter_signal;
00392       
00393       Watches m_unhandled_watches;
00394       
00395       typedef std::map<DBusTimeout*,Timeout::pointer> Timeouts;
00396 
00397       Timeouts m_timeouts;
00398 
00399       friend void init(bool);
00400 
00401       void initialize( bool is_private );
00402 
00403       static dbus_int32_t m_weak_pointer_slot;
00404 
00405       std::map<std::string,ObjectPathHandler::pointer> m_created_objects;
00406 
00407       InterfaceToNameProxySignalMap m_proxy_signal_interface_map;
00408 
00409 //       std::map<SignalReceiver::pointer, sigc::connection> m_sighandler_iface_conn;
00410 
00411 //       std::map<SignalReceiver::pointer, sigc::connection> m_sighandler_member_conn;
00412 
00413 //       void on_signal_handler_interface_changed(SignalReceiver::pointer handler);
00414 
00415 //       void on_signal_handler_member_changed(SignalReceiver::pointer handler);
00416 
00417 //       typedef std::map<std::string,signal_base> SignalVTable;
00418 //
00419 //       typedef std::map<std::string, SignalVTable> InterfaceVTable;
00420 
00421       static dbus_bool_t on_add_watch_callback( DBusWatch* cwatch, void* data );
00422 
00423       static void on_remove_watch_callback( DBusWatch* cwatch, void* data );
00424 
00425       static void on_watch_toggled_callback( DBusWatch* cwatch, void* data );
00426 
00427       static dbus_bool_t on_add_timeout_callback( DBusTimeout* ctimeout, void* data );
00428 
00429       static void on_remove_timeout_callback( DBusTimeout* ctimeout, void* data );
00430 
00431       static void on_timeout_toggled_callback( DBusTimeout* ctimeout, void* data );
00432 
00433       static void on_wakeup_main_callback( void* data );
00434 
00435       static void on_dispatch_status_callback( DBusConnection* connection, DBusDispatchStatus new_status, void* data );
00436 
00437       static DBusHandlerResult on_filter_callback( DBusConnection* connection, DBusMessage* message, void* data );
00438 
00439   };
00440   
00441   inline
00442   Connection::pointer operator<<(Connection::pointer ptr, Message::pointer msg)
00443   {
00444     if (not ptr) return ptr;
00445     *ptr << msg;
00446     return ptr;
00447   }
00448 
00449   inline
00450   Connection::pointer operator<<(Connection::pointer ptr, Message::const_pointer msg)
00451   {
00452     if (not ptr) return ptr;
00453     *ptr << msg;
00454     return ptr;
00455   }
00456 
00457   inline
00458   Connection::pointer operator<<(Connection::pointer ptr, ReturnMessage::pointer msg)
00459   {
00460     if (not ptr) return ptr;
00461     *ptr << msg;
00462     return ptr;
00463   }
00464 
00465   inline
00466   Connection::pointer operator<<(Connection::pointer ptr, ReturnMessage::const_pointer msg)
00467   {
00468     if (not ptr) return ptr;
00469     *ptr << msg;
00470     return ptr;
00471   }
00472 
00473   inline
00474   Connection::pointer operator<<(Connection::pointer ptr, SignalMessage::pointer msg)
00475   {
00476     if (not ptr) return ptr;
00477     *ptr << msg;
00478     return ptr;
00479   }
00480 
00481   inline
00482   Connection::pointer operator<<(Connection::pointer ptr, SignalMessage::const_pointer msg)
00483   {
00484     if (not ptr) return ptr;
00485     *ptr << msg;
00486     return ptr;
00487   }
00488 
00489 }
00490 
00491 #endif
00492 
00493 #include <dbus-cxx/method_impl.h>
00494 
00495 

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