glibmm: Gio::DBus Namespace Reference

glibmm 2.78.0

Namespaces | Classes | Typedefs | Enumerations | Functions
Gio::DBus Namespace Reference

## Namespaces
namespace | Address
namespace | ErrorUtils

## Classes
class | ActionGroup
| ActionGroup - A D-Bus Gio::ActionGroup implementation. More...
class | AnnotationInfo
| Stores information about an annotation. More...
class | ArgInfo
| ArgInfo - Stores information about an argument for a method or a signal. More...
class | AuthObserver
| AuthObserver - An object used for authenticating connections. More...
class | Connection
| A D-Bus Connection. More...
class | Error
class | Interface
| Interface - Base type for D-Bus interfaces. More...
class | InterfaceInfo
| Stores information about a D-Bus interface. More...
class | InterfaceSkeleton
| Abstract base class for D-Bus interfaces on the service side. More...
class | InterfaceVTable
| This represents a virtual table for handling properties and method calls for a D-Bus interface. More...
class | MenuModel
| MenuModel - A D-Bus Gio::MenuModel implementation. More...
class | Message
| A type for representing D-Bus messages that can be sent or received on a Connection. More...
class | MethodInfo
| Stores information about a method on an D-Bus interface. More...
class | MethodInvocation
| An Object for handling remote calls. More...
class | NodeInfo
| NodeInfo - Stores information about nodes in a remote object hierarchy. More...
class | Object
| Object - Base type for D-Bus objects. More...
class | ObjectManager
| Base type for D-Bus object managers. More...
class | ObjectManagerClient
| Client-side object manager. More...
class | ObjectManagerServer
| Service-side object manager. More...
class | ObjectProxy
| Client-side D-Bus object. More...
class | ObjectSkeleton
| Service-side D-Bus object. More...
class | PropertyInfo
| Stores information about a property on a D-Bus interface. More...
class | Proxy
| A client-side proxy. More...
class | Server
| This is a helper for listening to and accepting D-Bus connections. More...
class | SignalInfo
| Stores information about a signal on a D-Bus interface. More...
class | SubtreeVTable
| This represents a virtual table for subtrees registered with Gio::DBus::Connection::register_subtree(). More...

## Typedefs
using | SlotBusAcquired = sigc::slot< void(const Glib::RefPtr< Gio::DBus::Connection > &, Glib::ustring)>
| For example, void on_bus_acquired(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name);.
using | SlotNameAcquired = sigc::slot< void(const Glib::RefPtr< Gio::DBus::Connection > &, Glib::ustring)>
| For example, void on_name_acquired(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name);.
using | SlotNameLost = sigc::slot< void(const Glib::RefPtr< Gio::DBus::Connection > &, Glib::ustring)>
| For example, void on_name_lost(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name);.
using | SlotNameAppeared = sigc::slot< void(const Glib::RefPtr< Gio::DBus::Connection > &, Glib::ustring, const Glib::ustring &)>
| For example, void on_name_appeared(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name, const Glib::ustring& name_owner);.
using | SlotNameVanished = sigc::slot< void(const Glib::RefPtr< Gio::DBus::Connection > &, Glib::ustring)>
| For example, void on_name_vanished(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name);.

## Enumerations
enum class | BusType { STARTER = -1 , NONE , SYSTEM , SESSION }
enum class | CallFlags { NONE = 0x0 , NO_AUTO_START = (1<<0) , ALLOW_INTERACTIVE_AUTHORIZATION = (1<<1) }
enum class | ConnectionFlags { NONE = 0x0 , AUTHENTICATION_CLIENT = (1<<0) , AUTHENTICATION_SERVER = (1<<1) , AUTHENTICATION_ALLOW_ANONYMOUS = (1<<2) , MESSAGE_BUS_CONNECTION = (1<<3) , DELAY_MESSAGE_PROCESSING = (1<<4) , AUTHENTICATION_REQUIRE_SAME_USER = (1<<5) , CROSS_NAMESPACE = (1<<6) }
enum class | SendMessageFlags { NONE = 0x0 , PRESERVE_SERIAL = (1<<0) }
enum class | SignalFlags { NONE = 0x0 , NO_MATCH_RULE = (1<<0) , MATCH_ARG0_NAMESPACE = (1<<1) , MATCH_ARG0_PATH = (1<<2) }
enum class | SubtreeFlags { NONE = 0x0 , DISPATCH_TO_UNENUMERATED_NODES = (1<<0) }
enum class | PropertyInfoFlags { NONE = 0x0 , READABLE = (1<<0) , WRITABLE = (1<<1) }
enum class | MessageType { INVALID , METHOD_CALL , METHOD_RETURN , ERROR , SIGNAL }
enum class | MessageFlags { NONE = 0x0 , NO_REPLY_EXPECTED = (1<<0) , NO_AUTO_START = (1<<1) , ALLOW_INTERACTIVE_AUTHORIZATION = (1<<2) }
enum class | MessageHeaderField { INVALID , PATH , INTERFACE , MEMBER , ERROR_NAME , REPLY_SERIAL , DESTINATION , SENDER , SIGNATURE , NUM_UNIX_FDS }
enum class | CapabilityFlags { NONE = 0x0 , UNIX_FD_PASSING = (1<<0) }
enum class | BusNameOwnerFlags { NONE = 0x0 , ALLOW_REPLACEMENT = (1<<0) , REPLACE = (1<<1) , DO_NOT_QUEUE = (1<<2) }
enum class | ProxyFlags { NONE = 0x0 , DO_NOT_LOAD_PROPERTIES = (1<<0) , DO_NOT_CONNECT_SIGNALS = (1<<1) , DO_NOT_AUTO_START = (1<<2) , GET_INVALIDATED_PROPERTIES = (1<<3) , DO_NOT_AUTO_START_AT_CONSTRUCTION = (1<<4) , NO_MATCH_RULE = (1<<5) }
enum class | BusNameWatcherFlags { NONE = 0x0 , AUTO_START = (1<<0) }

## Functions
CallFlags | operator| (CallFlags lhs, CallFlags rhs)
CallFlags | operator& (CallFlags lhs, CallFlags rhs)
CallFlags | operator^ (CallFlags lhs, CallFlags rhs)
CallFlags | operator~ (CallFlags flags)
CallFlags & | operator|= (CallFlags &lhs, CallFlags rhs)
CallFlags & | operator&= (CallFlags &lhs, CallFlags rhs)
CallFlags & | operator^= (CallFlags &lhs, CallFlags rhs)
ConnectionFlags | operator| (ConnectionFlags lhs, ConnectionFlags rhs)
ConnectionFlags | operator& (ConnectionFlags lhs, ConnectionFlags rhs)
ConnectionFlags | operator^ (ConnectionFlags lhs, ConnectionFlags rhs)
ConnectionFlags | operator~ (ConnectionFlags flags)
ConnectionFlags & | operator|= (ConnectionFlags &lhs, ConnectionFlags rhs)
ConnectionFlags & | operator&= (ConnectionFlags &lhs, ConnectionFlags rhs)
ConnectionFlags & | operator^= (ConnectionFlags &lhs, ConnectionFlags rhs)
SendMessageFlags | operator| (SendMessageFlags lhs, SendMessageFlags rhs)
SendMessageFlags | operator& (SendMessageFlags lhs, SendMessageFlags rhs)
SendMessageFlags | operator^ (SendMessageFlags lhs, SendMessageFlags rhs)
SendMessageFlags | operator~ (SendMessageFlags flags)
SendMessageFlags & | operator|= (SendMessageFlags &lhs, SendMessageFlags rhs)
SendMessageFlags & | operator&= (SendMessageFlags &lhs, SendMessageFlags rhs)
SendMessageFlags & | operator^= (SendMessageFlags &lhs, SendMessageFlags rhs)
SignalFlags | operator| (SignalFlags lhs, SignalFlags rhs)
SignalFlags | operator& (SignalFlags lhs, SignalFlags rhs)
SignalFlags | operator^ (SignalFlags lhs, SignalFlags rhs)
SignalFlags | operator~ (SignalFlags flags)
SignalFlags & | operator|= (SignalFlags &lhs, SignalFlags rhs)
SignalFlags & | operator&= (SignalFlags &lhs, SignalFlags rhs)
SignalFlags & | operator^= (SignalFlags &lhs, SignalFlags rhs)
SubtreeFlags | operator| (SubtreeFlags lhs, SubtreeFlags rhs)
SubtreeFlags | operator& (SubtreeFlags lhs, SubtreeFlags rhs)
SubtreeFlags | operator^ (SubtreeFlags lhs, SubtreeFlags rhs)
SubtreeFlags | operator~ (SubtreeFlags flags)
SubtreeFlags & | operator|= (SubtreeFlags &lhs, SubtreeFlags rhs)
SubtreeFlags & | operator&= (SubtreeFlags &lhs, SubtreeFlags rhs)
SubtreeFlags & | operator^= (SubtreeFlags &lhs, SubtreeFlags rhs)
InterfaceSkeleton::Flags | operator| (InterfaceSkeleton::Flags lhs, InterfaceSkeleton::Flags rhs)
InterfaceSkeleton::Flags | operator& (InterfaceSkeleton::Flags lhs, InterfaceSkeleton::Flags rhs)
InterfaceSkeleton::Flags | operator^ (InterfaceSkeleton::Flags lhs, InterfaceSkeleton::Flags rhs)
InterfaceSkeleton::Flags | operator~ (InterfaceSkeleton::Flags flags)
InterfaceSkeleton::Flags & | operator|= (InterfaceSkeleton::Flags &lhs, InterfaceSkeleton::Flags rhs)
InterfaceSkeleton::Flags & | operator&= (InterfaceSkeleton::Flags &lhs, InterfaceSkeleton::Flags rhs)
InterfaceSkeleton::Flags & | operator^= (InterfaceSkeleton::Flags &lhs, InterfaceSkeleton::Flags rhs)
PropertyInfoFlags | operator| (PropertyInfoFlags lhs, PropertyInfoFlags rhs)
PropertyInfoFlags | operator& (PropertyInfoFlags lhs, PropertyInfoFlags rhs)
PropertyInfoFlags | operator^ (PropertyInfoFlags lhs, PropertyInfoFlags rhs)
PropertyInfoFlags | operator~ (PropertyInfoFlags flags)
PropertyInfoFlags & | operator|= (PropertyInfoFlags &lhs, PropertyInfoFlags rhs)
PropertyInfoFlags & | operator&= (PropertyInfoFlags &lhs, PropertyInfoFlags rhs)
PropertyInfoFlags & | operator^= (PropertyInfoFlags &lhs, PropertyInfoFlags rhs)
MessageFlags | operator| (MessageFlags lhs, MessageFlags rhs)
MessageFlags | operator& (MessageFlags lhs, MessageFlags rhs)
MessageFlags | operator^ (MessageFlags lhs, MessageFlags rhs)
MessageFlags | operator~ (MessageFlags flags)
MessageFlags & | operator|= (MessageFlags &lhs, MessageFlags rhs)
MessageFlags & | operator&= (MessageFlags &lhs, MessageFlags rhs)
MessageFlags & | operator^= (MessageFlags &lhs, MessageFlags rhs)
CapabilityFlags | operator| (CapabilityFlags lhs, CapabilityFlags rhs)
CapabilityFlags | operator& (CapabilityFlags lhs, CapabilityFlags rhs)
CapabilityFlags | operator^ (CapabilityFlags lhs, CapabilityFlags rhs)
CapabilityFlags | operator~ (CapabilityFlags flags)
CapabilityFlags & | operator|= (CapabilityFlags &lhs, CapabilityFlags rhs)
CapabilityFlags & | operator&= (CapabilityFlags &lhs, CapabilityFlags rhs)
CapabilityFlags & | operator^= (CapabilityFlags &lhs, CapabilityFlags rhs)
ObjectManagerClient::Flags | operator| (ObjectManagerClient::Flags lhs, ObjectManagerClient::Flags rhs)
ObjectManagerClient::Flags | operator& (ObjectManagerClient::Flags lhs, ObjectManagerClient::Flags rhs)
ObjectManagerClient::Flags | operator^ (ObjectManagerClient::Flags lhs, ObjectManagerClient::Flags rhs)
ObjectManagerClient::Flags | operator~ (ObjectManagerClient::Flags flags)
ObjectManagerClient::Flags & | operator|= (ObjectManagerClient::Flags &lhs, ObjectManagerClient::Flags rhs)
ObjectManagerClient::Flags & | operator&= (ObjectManagerClient::Flags &lhs, ObjectManagerClient::Flags rhs)
ObjectManagerClient::Flags & | operator^= (ObjectManagerClient::Flags &lhs, ObjectManagerClient::Flags rhs)
BusNameOwnerFlags | operator| (BusNameOwnerFlags lhs, BusNameOwnerFlags rhs)
BusNameOwnerFlags | operator& (BusNameOwnerFlags lhs, BusNameOwnerFlags rhs)
BusNameOwnerFlags | operator^ (BusNameOwnerFlags lhs, BusNameOwnerFlags rhs)
BusNameOwnerFlags | operator~ (BusNameOwnerFlags flags)
BusNameOwnerFlags & | operator|= (BusNameOwnerFlags &lhs, BusNameOwnerFlags rhs)
BusNameOwnerFlags & | operator&= (BusNameOwnerFlags &lhs, BusNameOwnerFlags rhs)
BusNameOwnerFlags & | operator^= (BusNameOwnerFlags &lhs, BusNameOwnerFlags rhs)
guint | own_name (BusType bus_type, const Glib::ustring & name, const SlotBusAcquired &bus_acquired_slot={}, const SlotNameAcquired &name_acquired_slot={}, const SlotNameLost &name_lost_slot={}, BusNameOwnerFlags flags=Gio::DBus::BusNameOwnerFlags::NONE)
| Starts acquiring name on the bus specified by bus_type and calls name_acquired_slot and name_lost_slot when the name is acquired respectively lost.
void | unown_name (guint owner_id)
| Stops owning a name.
ProxyFlags | operator| (ProxyFlags lhs, ProxyFlags rhs)
ProxyFlags | operator& (ProxyFlags lhs, ProxyFlags rhs)
ProxyFlags | operator^ (ProxyFlags lhs, ProxyFlags rhs)
ProxyFlags | operator~ (ProxyFlags flags)
ProxyFlags & | operator|= (ProxyFlags &lhs, ProxyFlags rhs)
ProxyFlags & | operator&= (ProxyFlags &lhs, ProxyFlags rhs)
ProxyFlags & | operator^= (ProxyFlags &lhs, ProxyFlags rhs)
Server::Flags | operator| (Server::Flags lhs, Server::Flags rhs)
Server::Flags | operator& (Server::Flags lhs, Server::Flags rhs)
Server::Flags | operator^ (Server::Flags lhs, Server::Flags rhs)
Server::Flags | operator~ (Server::Flags flags)
Server::Flags & | operator|= (Server::Flags &lhs, Server::Flags rhs)
Server::Flags & | operator&= (Server::Flags &lhs, Server::Flags rhs)
Server::Flags & | operator^= (Server::Flags &lhs, Server::Flags rhs)
std::string | generate_guid ()
| Generate a D-Bus GUID that can be used with e.g.
bool | is_guid (const std::string &string)
| Checks if string is a D-Bus GUID.
bool | is_name (const Glib::ustring &string)
| Checks if string is a valid D-Bus bus name (either unique or well-known).
bool | is_unique_name (const Glib::ustring &string)
| Checks if string is a valid D-Bus unique bus name.
bool | is_member_name (const Glib::ustring &string)
| Checks if string is a valid D-Bus member (e.g.
bool | is_interface_name (const Glib::ustring &string)
| Checks if string is a valid D-Bus interface name.
BusNameWatcherFlags | operator| (BusNameWatcherFlags lhs, BusNameWatcherFlags rhs)
BusNameWatcherFlags | operator& (BusNameWatcherFlags lhs, BusNameWatcherFlags rhs)
BusNameWatcherFlags | operator^ (BusNameWatcherFlags lhs, BusNameWatcherFlags rhs)
BusNameWatcherFlags | operator~ (BusNameWatcherFlags flags)
BusNameWatcherFlags & | operator|= (BusNameWatcherFlags &lhs, BusNameWatcherFlags rhs)
BusNameWatcherFlags & | operator&= (BusNameWatcherFlags &lhs, BusNameWatcherFlags rhs)
BusNameWatcherFlags & | operator^= (BusNameWatcherFlags &lhs, BusNameWatcherFlags rhs)
guint | watch_name (BusType bus_type, const Glib::ustring & name, const SlotNameAppeared &name_appeared_slot={}, const SlotNameVanished &name_vanished_slot={}, BusNameWatcherFlags flags=Gio::DBus::BusNameWatcherFlags::NONE)
| Starts watching name on the bus specified by bus_type and calls name_appeared_slot and name_vanished_slot when the name is known to have a owner respectively known to lose its owner.
guint | watch_name (const Glib::RefPtr< Connection > &connection, const Glib::ustring & name, const SlotNameAppeared &name_appeared_slot={}, const SlotNameVanished &name_vanished_slot={}, BusNameWatcherFlags flags=Gio::DBus::BusNameWatcherFlags::NONE)
| A watch_name() function that takes a Connection instead of a BusType.
void | unwatch_name (guint watcher_id)
| Stops watching a name.

## Enumeration Type Documentation

## ◆ BusNameOwnerFlags

enum class Gio::DBus::BusNameOwnerFlags
| strong

Enumerator
NONE |
ALLOW_REPLACEMENT | Allow another message bus connection to claim the name.
REPLACE | If another message bus connection owns the name and have specified Gio::DBus::BusNameOwnerFlags::ALLOW_REPLACEMENT, then take the name from the other connection.
DO_NOT_QUEUE | If another message bus connection owns the name, immediately return an error from g_bus_own_name() rather than entering the waiting queue for that name. (Since 2.54).

## ◆ BusNameWatcherFlags

enum class Gio::DBus::BusNameWatcherFlags
| strong

Enumerator
NONE |
AUTO_START | If no-one owns the name when beginning to watch the name, ask the bus to launch an owner for the name.

## ◆ BusType

enum class Gio::DBus::BusType
| strong

Enumerator
STARTER | An alias for the message bus that activated the process, if any.
NONE | Not a message bus. No flags set.
SYSTEM | The system-wide message bus.
SESSION | The login session message bus.

## ◆ CallFlags

enum class Gio::DBus::CallFlags
| strong

Enumerator
NONE |
NO_AUTO_START | The bus must not launch an owner for the destination name in response to this method invocation. The bus must not launch an owner for the destination name in response to this message.
ALLOW_INTERACTIVE_AUTHORIZATION | The caller is prepared to wait for interactive authorization. If set on a method call, this flag means that the caller is prepared to wait for interactive authorization. Since glibmm 2.46: Since glibmm 2.46:

## ◆ CapabilityFlags

enum class Gio::DBus::CapabilityFlags
| strong

Enumerator
NONE |
UNIX_FD_PASSING | The connection supports exchanging UNIX file descriptors with the remote peer.

## ◆ ConnectionFlags

enum class Gio::DBus::ConnectionFlags
| strong

Enumerator
NONE |
AUTHENTICATION_CLIENT | Perform authentication against server.
AUTHENTICATION_SERVER | Perform authentication against client.
AUTHENTICATION_ALLOW_ANONYMOUS | When authenticating as a server, allow the anonymous authentication method.
MESSAGE_BUS_CONNECTION | Pass this flag if connecting to a peer that is a message bus. This means that the Hello() method will be invoked as part of the connection setup.
DELAY_MESSAGE_PROCESSING | If set, processing of D-Bus messages is delayed until g_dbus_connection_start_message_processing() is called.
AUTHENTICATION_REQUIRE_SAME_USER | When authenticating as a server, require the UID of the peer to be the same as the UID of the server. (Since: 2.68).
CROSS_NAMESPACE | When authenticating, try to use protocols that work across a Linux user namespace boundary, even if this reduces interoperability with older D-Bus implementations. This currently affects client-side `EXTERNAL` authentication, for which this flag makes connections to a server in another user namespace succeed, but causes a deadlock when connecting to a GDBus server older than 2.73.3. Since glibmm 2.74:

## ◆ MessageFlags

enum class Gio::DBus::MessageFlags
| strong

Enumerator
NONE |
NO_REPLY_EXPECTED | A reply is not expected.
NO_AUTO_START |
ALLOW_INTERACTIVE_AUTHORIZATION |

## ◆ MessageHeaderField

enum class Gio::DBus::MessageHeaderField
| strong

Enumerator
INVALID |
PATH | The object path.
INTERFACE | The interface name.
MEMBER | The method or signal name.
ERROR_NAME | The name of the error that occurred.
REPLY_SERIAL | The serial number the message is a reply to.
DESTINATION | The name the message is intended for.
SENDER | Unique name of the sender of the message (filled in by the bus).
SIGNATURE | The signature of the message body.
NUM_UNIX_FDS | The number of UNIX file descriptors that accompany the message.

## ◆ MessageType

enum class Gio::DBus::MessageType
| strong

Enumerator
INVALID | Message is of invalid type. Not a valid header field.
METHOD_CALL | Method call.
METHOD_RETURN | Method reply.
ERROR | Error reply.
SIGNAL | Signal emission.

## ◆ PropertyInfoFlags

enum class Gio::DBus::PropertyInfoFlags
| strong

Enumerator
NONE |
READABLE | Property is readable.
WRITABLE | Property is writable.

## ◆ ProxyFlags

enum class Gio::DBus::ProxyFlags
| strong

Enumerator
NONE |
DO_NOT_LOAD_PROPERTIES | Don't load properties.
DO_NOT_CONNECT_SIGNALS | Don't connect to signals on the remote object.
DO_NOT_AUTO_START | If the proxy is for a well-known name, do not ask the bus to launch an owner during proxy initialization or a method call. This flag is only meaningful in proxies for well-known names.
GET_INVALIDATED_PROPERTIES | If set, the property value for any invalidated property will be (asynchronously) retrieved upon receiving the `PropertiesChanged` D-Bus signal and the property will not cause emission of the Gio::DBus::Proxy::signal_g_properties_changed() signal. When the value is received the Gio::DBus::Proxy::signal_g_properties_changed() signal is emitted for the property along with the retrieved value. Since glibmm 2.32:
DO_NOT_AUTO_START_AT_CONSTRUCTION | If the proxy is for a well-known name, do not ask the bus to launch an owner during proxy initialization, but allow it to be autostarted by a method call. This flag is only meaningful in proxies for well-known names, and only if Gio::DBus::ProxyFlags::DO_NOT_AUTO_START is not also specified.
NO_MATCH_RULE |

## ◆ SendMessageFlags

enum class Gio::DBus::SendMessageFlags
| strong

Enumerator
NONE |
PRESERVE_SERIAL | Do not automatically assign a serial number from the Gio::DBus::Connection object when sending a message.

## ◆ SignalFlags

enum class Gio::DBus::SignalFlags
| strong

Enumerator
NONE |
NO_MATCH_RULE | Don't actually send the AddMatch D-Bus call for this signal subscription. This gives you more control over which match rules you add (but you must add them manually). This gives you more control over which match rules you add (but you must add them manually). (Since: 2.72).
MATCH_ARG0_NAMESPACE | Match first arguments that contain a bus or interface name with the given namespace.
MATCH_ARG0_PATH | Match first arguments that contain an object path that is either equivalent to the given path, or one of the paths is a subpath of the other.

## ◆ SubtreeFlags

enum class Gio::DBus::SubtreeFlags
| strong

Enumerator
NONE |
DISPATCH_TO_UNENUMERATED_NODES | Method calls to objects not in the enumerated range will still be dispatched. This is useful if you want to dynamically spawn objects in the subtree.

## Function Documentation

## ◆ unown_name()

void Gio::DBus::unown_name | ( | guint | owner_id | ) |

Stops owning a name.

Parameters

  owner_id | An identifier obtained from own_name().