From a47345309cbb627c3a5a48f2a14a863cccdaae0a Mon Sep 17 00:00:00 2001 From: Colin Walters Date: Tue, 28 May 2013 14:44:15 -0400 Subject: Update annotations from glib git --- gir/gio-2.0.c | 1449 ++++++++++++++++++++++++++++++++++++++++++++++++++++- gir/glib-2.0.c | 183 +++++-- gir/gobject-2.0.c | 6 +- 3 files changed, 1599 insertions(+), 39 deletions(-) diff --git a/gir/gio-2.0.c b/gir/gio-2.0.c index 26058de3..999b130b 100644 --- a/gir/gio-2.0.c +++ b/gir/gio-2.0.c @@ -6730,7 +6730,7 @@ * GSocketAddress *sockaddr; * GError *conn_error = NULL; * - * addr = g_network_address_new ("www.gnome.org", 80); + * addr = g_network_address_new (hostname, port); * enumerator = g_socket_connectable_enumerate (addr); * g_object_unref (addr); * @@ -9471,6 +9471,1449 @@ */ +/** + * _GFreedesktopDBus: + * + * Abstract interface type for the D-Bus interface org.freedesktop.DBus. + */ + + +/** + * _GFreedesktopDBus::handle-add-match: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_rule: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the AddMatch() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_add_match() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-get-connection-selinux-security-context: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_name: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the GetConnectionSELinuxSecurityContext() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_get_connection_selinux_security_context() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-get-connection-unix-process-id: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_name: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the GetConnectionUnixProcessID() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_get_connection_unix_process_id() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-get-connection-unix-user: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_name: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the GetConnectionUnixUser() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_get_connection_unix_user() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-get-id: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the GetId() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_get_id() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-get-name-owner: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_name: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the GetNameOwner() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_get_name_owner() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-hello: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the Hello() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_hello() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-list-activatable-names: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the ListActivatableNames() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_list_activatable_names() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-list-names: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the ListNames() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_list_names() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-list-queued-owners: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_name: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ListQueuedOwners() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_list_queued_owners() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-name-has-owner: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_name: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the NameHasOwner() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_name_has_owner() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-release-name: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_name: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ReleaseName() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_release_name() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-reload-config: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the ReloadConfig() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_reload_config() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-remove-match: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_rule: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the RemoveMatch() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_remove_match() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-request-name: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_name: Argument passed by remote caller. + * @arg_flags: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the RequestName() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_request_name() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-start-service-by-name: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_name: Argument passed by remote caller. + * @arg_flags: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the StartServiceByName() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_start_service_by_name() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::handle-update-activation-environment: + * @object: A #_GFreedesktopDBus. + * @invocation: A #GDBusMethodInvocation. + * @arg_environment: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the UpdateActivationEnvironment() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call _g_freedesktop_dbus_complete_update_activation_environment() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + + +/** + * _GFreedesktopDBus::name-acquired: + * @object: A #_GFreedesktopDBus. + * @arg_name: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "NameAcquired" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + + +/** + * _GFreedesktopDBus::name-lost: + * @object: A #_GFreedesktopDBus. + * @arg_name: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "NameLost" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + + +/** + * _GFreedesktopDBus::name-owner-changed: + * @object: A #_GFreedesktopDBus. + * @arg_name: Argument. + * @arg_old_owner: Argument. + * @arg_new_owner: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "NameOwnerChanged" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + + +/** + * _GFreedesktopDBusIface: + * @parent_iface: The parent interface. + * @handle_add_match: Handler for the #_GFreedesktopDBus::handle-add-match signal. + * @handle_get_connection_selinux_security_context: Handler for the #_GFreedesktopDBus::handle-get-connection-selinux-security-context signal. + * @handle_get_connection_unix_process_id: Handler for the #_GFreedesktopDBus::handle-get-connection-unix-process-id signal. + * @handle_get_connection_unix_user: Handler for the #_GFreedesktopDBus::handle-get-connection-unix-user signal. + * @handle_get_id: Handler for the #_GFreedesktopDBus::handle-get-id signal. + * @handle_get_name_owner: Handler for the #_GFreedesktopDBus::handle-get-name-owner signal. + * @handle_hello: Handler for the #_GFreedesktopDBus::handle-hello signal. + * @handle_list_activatable_names: Handler for the #_GFreedesktopDBus::handle-list-activatable-names signal. + * @handle_list_names: Handler for the #_GFreedesktopDBus::handle-list-names signal. + * @handle_list_queued_owners: Handler for the #_GFreedesktopDBus::handle-list-queued-owners signal. + * @handle_name_has_owner: Handler for the #_GFreedesktopDBus::handle-name-has-owner signal. + * @handle_release_name: Handler for the #_GFreedesktopDBus::handle-release-name signal. + * @handle_reload_config: Handler for the #_GFreedesktopDBus::handle-reload-config signal. + * @handle_remove_match: Handler for the #_GFreedesktopDBus::handle-remove-match signal. + * @handle_request_name: Handler for the #_GFreedesktopDBus::handle-request-name signal. + * @handle_start_service_by_name: Handler for the #_GFreedesktopDBus::handle-start-service-by-name signal. + * @handle_update_activation_environment: Handler for the #_GFreedesktopDBus::handle-update-activation-environment signal. + * @name_acquired: Handler for the #_GFreedesktopDBus::name-acquired signal. + * @name_lost: Handler for the #_GFreedesktopDBus::name-lost signal. + * @name_owner_changed: Handler for the #_GFreedesktopDBus::name-owner-changed signal. + * + * Virtual table for the D-Bus interface org.freedesktop.DBus. + */ + + +/** + * _GFreedesktopDBusProxy: + * + * The #_GFreedesktopDBusProxy structure contains only private data and should only be accessed using the provided API. + */ + + +/** + * _GFreedesktopDBusProxyClass: + * @parent_class: The parent class. + * + * Class structure for #_GFreedesktopDBusProxy. + */ + + +/** + * _GFreedesktopDBusSkeleton: + * + * The #_GFreedesktopDBusSkeleton structure contains only private data and should only be accessed using the provided API. + */ + + +/** + * _GFreedesktopDBusSkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #_GFreedesktopDBusSkeleton. + */ + + +/** + * _g_freedesktop_dbus_call_add_match: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_rule: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the AddMatch() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_add_match_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_add_match_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_add_match_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_add_match(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_add_match(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_add_match_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_rule: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the AddMatch() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_add_match() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_get_connection_selinux_security_context: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetConnectionSELinuxSecurityContext() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_get_connection_selinux_security_context_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_get_connection_selinux_security_context_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_get_connection_selinux_security_context_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_security_context: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_get_connection_selinux_security_context(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_get_connection_selinux_security_context(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_get_connection_selinux_security_context_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @out_security_context: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetConnectionSELinuxSecurityContext() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_get_connection_selinux_security_context() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_get_connection_unix_process_id: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetConnectionUnixProcessID() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_get_connection_unix_process_id_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_get_connection_unix_process_id_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_get_connection_unix_process_id_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_pid: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_get_connection_unix_process_id(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_get_connection_unix_process_id(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_get_connection_unix_process_id_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @out_pid: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetConnectionUnixProcessID() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_get_connection_unix_process_id() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_get_connection_unix_user: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetConnectionUnixUser() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_get_connection_unix_user_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_get_connection_unix_user_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_get_connection_unix_user_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_uid: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_get_connection_unix_user(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_get_connection_unix_user(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_get_connection_unix_user_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @out_uid: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetConnectionUnixUser() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_get_connection_unix_user() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_get_id: + * @proxy: A #_GFreedesktopDBusProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetId() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_get_id_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_get_id_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_get_id_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_unique_id: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_get_id(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_get_id(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_get_id_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_unique_id: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetId() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_get_id() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_get_name_owner: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetNameOwner() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_get_name_owner_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_get_name_owner_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_get_name_owner_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_unique_name: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_get_name_owner(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_get_name_owner(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_get_name_owner_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @out_unique_name: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetNameOwner() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_get_name_owner() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_hello: + * @proxy: A #_GFreedesktopDBusProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Hello() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_hello_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_hello_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_hello_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_assigned_name: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_hello(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_hello(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_hello_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_assigned_name: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Hello() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_hello() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_list_activatable_names: + * @proxy: A #_GFreedesktopDBusProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ListActivatableNames() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_list_activatable_names_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_list_activatable_names_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_list_activatable_names_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_activatable_names: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_list_activatable_names(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_list_activatable_names(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_list_activatable_names_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_activatable_names: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ListActivatableNames() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_list_activatable_names() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_list_names: + * @proxy: A #_GFreedesktopDBusProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ListNames() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_list_names_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_list_names_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_list_names_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_names: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_list_names(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_list_names(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_list_names_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_names: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ListNames() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_list_names() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_list_queued_owners: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ListQueuedOwners() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_list_queued_owners_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_list_queued_owners_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_list_queued_owners_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_queued_owners: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_list_queued_owners(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_list_queued_owners(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_list_queued_owners_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @out_queued_owners: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ListQueuedOwners() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_list_queued_owners() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_name_has_owner: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the NameHasOwner() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_name_has_owner_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_name_has_owner_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_name_has_owner_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_has_owner: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_name_has_owner(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_name_has_owner(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_name_has_owner_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @out_has_owner: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the NameHasOwner() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_name_has_owner() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_release_name: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ReleaseName() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_release_name_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_release_name_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_release_name_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_value: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_release_name(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_release_name(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_release_name_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @out_value: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ReleaseName() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_release_name() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_reload_config: + * @proxy: A #_GFreedesktopDBusProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ReloadConfig() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_reload_config_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_reload_config_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_reload_config_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_reload_config(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_reload_config(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_reload_config_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ReloadConfig() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_reload_config() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_remove_match: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_rule: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the RemoveMatch() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_remove_match_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_remove_match_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_remove_match_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_remove_match(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_remove_match(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_remove_match_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_rule: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the RemoveMatch() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_remove_match() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_request_name: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @arg_flags: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the RequestName() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_request_name_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_request_name_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_request_name_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_value: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_request_name(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_request_name(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_request_name_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @arg_flags: Argument to pass with the method invocation. + * @out_value: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the RequestName() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_request_name() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_start_service_by_name: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @arg_flags: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the StartServiceByName() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_start_service_by_name_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_start_service_by_name_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_start_service_by_name_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @out_value: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_start_service_by_name(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_start_service_by_name(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_start_service_by_name_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_name: Argument to pass with the method invocation. + * @arg_flags: Argument to pass with the method invocation. + * @out_value: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the StartServiceByName() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_start_service_by_name() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_update_activation_environment: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_environment: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the UpdateActivationEnvironment() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_call_update_activation_environment_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_call_update_activation_environment_sync() for the synchronous, blocking version of this method. + */ + + +/** + * _g_freedesktop_dbus_call_update_activation_environment_finish: + * @proxy: A #_GFreedesktopDBusProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_call_update_activation_environment(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with _g_freedesktop_dbus_call_update_activation_environment(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_call_update_activation_environment_sync: + * @proxy: A #_GFreedesktopDBusProxy. + * @arg_environment: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the UpdateActivationEnvironment() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_call_update_activation_environment() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ + + +/** + * _g_freedesktop_dbus_complete_add_match: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the AddMatch() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_get_connection_selinux_security_context: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @security_context: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetConnectionSELinuxSecurityContext() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_get_connection_unix_process_id: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @pid: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetConnectionUnixProcessID() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_get_connection_unix_user: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @uid: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetConnectionUnixUser() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_get_id: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @unique_id: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetId() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_get_name_owner: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @unique_name: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetNameOwner() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_hello: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @assigned_name: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the Hello() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_list_activatable_names: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @activatable_names: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the ListActivatableNames() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_list_names: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @names: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the ListNames() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_list_queued_owners: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @queued_owners: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the ListQueuedOwners() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_name_has_owner: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @has_owner: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the NameHasOwner() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_release_name: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @value: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the ReleaseName() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_reload_config: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the ReloadConfig() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_remove_match: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the RemoveMatch() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_request_name: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @value: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the RequestName() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_start_service_by_name: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @value: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the StartServiceByName() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_complete_update_activation_environment: + * @object: A #_GFreedesktopDBus. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the UpdateActivationEnvironment() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ + + +/** + * _g_freedesktop_dbus_emit_name_acquired: + * @object: A #_GFreedesktopDBus. + * @arg_name: Argument to pass with the signal. + * + * Emits the "NameAcquired" D-Bus signal. + */ + + +/** + * _g_freedesktop_dbus_emit_name_lost: + * @object: A #_GFreedesktopDBus. + * @arg_name: Argument to pass with the signal. + * + * Emits the "NameLost" D-Bus signal. + */ + + +/** + * _g_freedesktop_dbus_emit_name_owner_changed: + * @object: A #_GFreedesktopDBus. + * @arg_name: Argument to pass with the signal. + * @arg_old_owner: Argument to pass with the signal. + * @arg_new_owner: Argument to pass with the signal. + * + * Emits the "NameOwnerChanged" D-Bus signal. + */ + + +/** + * _g_freedesktop_dbus_interface_info: + * + * Gets a machine-readable description of the org.freedesktop.DBus D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ + + +/** + * _g_freedesktop_dbus_override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #_GFreedesktopDBus interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ + + +/** + * _g_freedesktop_dbus_proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface org.freedesktop.DBus. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_proxy_new_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_proxy_new_sync() for the synchronous, blocking version of this constructor. + */ + + +/** + * _g_freedesktop_dbus_proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with _g_freedesktop_dbus_proxy_new(). + * + * Returns: (transfer full) (type _GFreedesktopDBusProxy): The constructed proxy object or %NULL if @error is set. + */ + + +/** + * _g_freedesktop_dbus_proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like _g_freedesktop_dbus_proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call _g_freedesktop_dbus_proxy_new_for_bus_finish() to get the result of the operation. + * + * See _g_freedesktop_dbus_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ + + +/** + * _g_freedesktop_dbus_proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to _g_freedesktop_dbus_proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with _g_freedesktop_dbus_proxy_new_for_bus(). + * + * Returns: (transfer full) (type _GFreedesktopDBusProxy): The constructed proxy object or %NULL if @error is set. + */ + + +/** + * _g_freedesktop_dbus_proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like _g_freedesktop_dbus_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type _GFreedesktopDBusProxy): The constructed proxy object or %NULL if @error is set. + */ + + +/** + * _g_freedesktop_dbus_proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface org.freedesktop.DBus. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See _g_freedesktop_dbus_proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type _GFreedesktopDBusProxy): The constructed proxy object or %NULL if @error is set. + */ + + +/** + * _g_freedesktop_dbus_skeleton_new: + * + * Creates a skeleton object for the D-Bus interface org.freedesktop.DBus. + * + * Returns: (transfer full) (type _GFreedesktopDBusSkeleton): The skeleton object. + */ + + /** * _g_io_module_get_default: * @extension_point: the name of an extension point @@ -9533,6 +10976,8 @@ * the parameter type given at construction time). If the parameter * type was %NULL then @parameter must also be %NULL. * + * If the @parameter GVariant is floating, it is consumed. + * * Since: 2.28 */ @@ -28779,6 +30224,8 @@ * property. Instead, they should call g_action_change_state() to * request the change. * + * If the @value GVariant is floating, it is consumed. + * * Since: 2.30 */ diff --git a/gir/glib-2.0.c b/gir/glib-2.0.c index 7cf2ffa0..ac8f7796 100644 --- a/gir/glib-2.0.c +++ b/gir/glib-2.0.c @@ -429,7 +429,7 @@ * @G_FILE_ERROR_NFILE: There are too many distinct file openings in the entire system. * @G_FILE_ERROR_BADF: Bad file descriptor; for example, I/O on a descriptor that has been closed or reading from a descriptor open only for writing (or vice versa). * @G_FILE_ERROR_INVAL: Invalid argument. This is used to indicate various kinds of problems with passing the wrong argument to a library function. - * @G_FILE_ERROR_PIPE: Broken pipe; there is no process reading from the other end of a pipe. Every library function that returns this error code also generates a `SIGPIPE' signal; this signal terminates the program if not handled or blocked. Thus, your program will never actually see this code unless it has handled or blocked `SIGPIPE'. + * @G_FILE_ERROR_PIPE: Broken pipe; there is no process reading from the other end of a pipe. Every library function that returns this error code also generates a 'SIGPIPE' signal; this signal terminates the program if not handled or blocked. Thus, your program will never actually see this code unless it has handled or blocked 'SIGPIPE'. * @G_FILE_ERROR_AGAIN: Resource temporarily unavailable; the call might work if you try again later. * @G_FILE_ERROR_INTR: Interrupted function call; an asynchronous signal occurred and prevented completion of the call. When this happens, you should try the call again. * @G_FILE_ERROR_IO: Input/output error; usually used for physical read or write errors. i.e. the disk or other physical device hardware is returning errors. @@ -1789,6 +1789,19 @@ */ +/** + * GTestSubprocessFlags: + * @G_TEST_SUBPROCESS_INHERIT_STDIN: If this flag is given, the child process will inherit the parent's stdin. Otherwise, the child's stdin is redirected to /dev/null. + * @G_TEST_SUBPROCESS_INHERIT_STDOUT: If this flag is given, the child process will inherit the parent's stdout. Otherwise, the child's stdout will not be visible, but it will be captured to allow later tests with g_test_trap_assert_stdout(). + * @G_TEST_SUBPROCESS_INHERIT_STDERR: If this flag is given, the child process will inherit the parent's stderr. Otherwise, the child's stderr will not be visible, but it will be captured to allow later tests with g_test_trap_assert_stderr(). + * + * Flags to pass to g_test_trap_subprocess() to control input and output. + * + * Note that in contrast with g_test_trap_fork(), the default is to + * not show stdout and stderr. + */ + + /** * GTestSuite: * @@ -1800,10 +1813,12 @@ * GTestTrapFlags: * @G_TEST_TRAP_SILENCE_STDOUT: Redirect stdout of the test child to /dev/null so it cannot be observed on the console during test runs. The actual output is still captured though to allow later tests with g_test_trap_assert_stdout(). * @G_TEST_TRAP_SILENCE_STDERR: Redirect stderr of the test child to /dev/null so it cannot be observed on the console during test runs. The actual output is still captured though to allow later tests with g_test_trap_assert_stderr(). - * @G_TEST_TRAP_INHERIT_STDIN: If this flag is given, stdin of the forked child process is shared with stdin of its parent process. It is redirected to /dev/null otherwise. + * @G_TEST_TRAP_INHERIT_STDIN: If this flag is given, stdin of the child process is shared with stdin of its parent process. It is redirected to /dev/null otherwise. * * Test traps are guards around forked tests. * These flags determine what traps to set. + * + * Deprecated: #GTestTrapFlags is used only with g_test_trap_fork(), which is deprecated. g_test_trap_subprocess() uses #GTestTrapSubprocessFlags. */ @@ -2877,7 +2892,7 @@ * format function the same as they would have been for the unmodified * string). * - * Place the attribute after the function declaration, just after the + * Place the attribute after the function declaration, just before the * semicolon. * * See the GNU C documentation for more details. @@ -27201,6 +27216,11 @@ * slash-separated portions of @testpath. The @test_data argument * will be passed as first argument to @test_func. * + * If @testpath includes the component "subprocess" anywhere in it, + * the test will be skipped by default, and only run if explicitly + * required via the command-line option or + * g_test_trap_subprocess(). + * * Since: 2.16 */ @@ -27229,6 +27249,11 @@ * created on the fly and added to the root fixture, based on the * slash-separated portions of @testpath. * + * If @testpath includes the component "subprocess" anywhere in it, + * the test will be skipped by default, and only run if explicitly + * required via the command-line option or + * g_test_trap_subprocess(). + * * Since: 2.16 */ @@ -27349,7 +27374,7 @@ * * Note that you cannot use this to test g_error() messages, since * g_error() intentionally never returns even if the program doesn't - * abort; use g_test_trap_fork() in this case. + * abort; use g_test_trap_subprocess() in this case. * * Since: 2.34 */ @@ -27421,6 +27446,8 @@ * * * Execute all tests matching TESTPATH. + * This can also be used to force a test to run that would otherwise + * be skipped (ie, a test whose name contains "/subprocess"). * * * @@ -27451,8 +27478,8 @@ * undefined * * Tests for undefined behaviour, may provoke programming errors - * under g_test_trap_fork() to check that appropriate assertions - * or warnings are given + * under g_test_trap_subprocess() or g_test_expect_messages() to check + * that appropriate assertions or warnings are given * * * @@ -27765,6 +27792,17 @@ */ +/** + * g_test_subprocess: + * + * Returns %TRUE (after g_test_init() has been called) if the test + * program is running under g_test_trap_subprocess(). + * + * Returns: %TRUE if the test program is running under g_test_trap_subprocess(). + * Since: 2.38 + */ + + /** * g_test_suite_add: * @suite: a #GTestSuite @@ -27830,13 +27868,13 @@ /** * g_test_trap_assert_failed: * - * Assert that the last forked test failed. - * See g_test_trap_fork(). + * Assert that the last test subprocess failed. + * See g_test_trap_subprocess(). * * This is sometimes used to test situations that are formally considered to * be undefined behaviour, like inputs that fail a g_return_if_fail() * check. In these situations you should skip the entire test, including the - * call to g_test_trap_fork(), unless g_test_undefined() returns %TRUE + * call to g_test_trap_subprocess(), unless g_test_undefined() returns %TRUE * to indicate that undefined behaviour may be tested. * * Since: 2.16 @@ -27846,8 +27884,8 @@ /** * g_test_trap_assert_passed: * - * Assert that the last forked test passed. - * See g_test_trap_fork(). + * Assert that the last test subprocess passed. + * See g_test_trap_subprocess(). * * Since: 2.16 */ @@ -27857,14 +27895,15 @@ * g_test_trap_assert_stderr: * @serrpattern: a glob-style pattern * - * Assert that the stderr output of the last forked test - * matches @serrpattern. See g_test_trap_fork(). + * Assert that the stderr output of the last test subprocess + * matches @serrpattern. See g_test_trap_subprocess(). * - * This is sometimes used to test situations that are formally considered to - * be undefined behaviour, like inputs that fail a g_return_if_fail() - * check. In these situations you should skip the entire test, including the - * call to g_test_trap_fork(), unless g_test_undefined() returns %TRUE - * to indicate that undefined behaviour may be tested. + * This is sometimes used to test situations that are formally + * considered to be undefined behaviour, like code that hits a + * g_assert() or g_error(). In these situations you should skip the + * entire test, including the call to g_test_trap_subprocess(), unless + * g_test_undefined() returns %TRUE to indicate that undefined + * behaviour may be tested. * * Since: 2.16 */ @@ -27874,8 +27913,8 @@ * g_test_trap_assert_stderr_unmatched: * @serrpattern: a glob-style pattern * - * Assert that the stderr output of the last forked test - * does not match @serrpattern. See g_test_trap_fork(). + * Assert that the stderr output of the last test subprocess + * does not match @serrpattern. See g_test_trap_subprocess(). * * Since: 2.16 */ @@ -27885,8 +27924,8 @@ * g_test_trap_assert_stdout: * @soutpattern: a glob-style pattern * - * Assert that the stdout output of the last forked test matches - * @soutpattern. See g_test_trap_fork(). + * Assert that the stdout output of the last test subprocess matches + * @soutpattern. See g_test_trap_subprocess(). * * Since: 2.16 */ @@ -27896,8 +27935,8 @@ * g_test_trap_assert_stdout_unmatched: * @soutpattern: a glob-style pattern * - * Assert that the stdout output of the last forked test - * does not match @soutpattern. See g_test_trap_fork(). + * Assert that the stdout output of the last test subprocess + * does not match @soutpattern. See g_test_trap_subprocess(). * * Since: 2.16 */ @@ -27909,8 +27948,10 @@ * @test_trap_flags: Flags to modify forking behaviour. * * Fork the current test program to execute a test case that might - * not return or that might abort. The forked test case is aborted - * and considered failing if its run time exceeds @usec_timeout. + * not return or that might abort. + * + * If @usec_timeout is non-0, the forked test case is aborted and + * considered failing if its run time exceeds it. * * The forking behavior can be configured with the #GTestTrapFlags flags. * @@ -27929,25 +27970,24 @@ * g_printerr ("some stderr text: semagic43\n"); * exit (0); /* successful test run */ * } - * g_test_trap_assert_passed(); + * g_test_trap_assert_passed (); * g_test_trap_assert_stdout ("*somagic17*"); * g_test_trap_assert_stderr ("*semagic43*"); * } * ]| * - * This function is implemented only on Unix platforms. - * * Returns: %TRUE for the forked child and %FALSE for the executing parent process. * Since: 2.16 + * Deprecated: This function is implemented only on Unix platforms, and is not always reliable due to problems inherent in fork-without-exec. Use g_test_trap_subprocess() instead. */ /** * g_test_trap_has_passed: * - * Check the result of the last g_test_trap_fork() call. + * Check the result of the last g_test_trap_subprocess() call. * - * Returns: %TRUE if the last forked child terminated successfully. + * Returns: %TRUE if the last test subprocess terminated successfully. * Since: 2.16 */ @@ -27955,20 +27995,91 @@ /** * g_test_trap_reached_timeout: * - * Check the result of the last g_test_trap_fork() call. + * Check the result of the last g_test_trap_subprocess() call. * - * Returns: %TRUE if the last forked child got killed due to a fork timeout. + * Returns: %TRUE if the last test subprocess got killed due to a timeout. * Since: 2.16 */ +/** + * g_test_trap_subprocess: + * @test_name: Test to run in a subprocess + * @usec_timeout: Timeout for the subprocess test in micro seconds. + * @test_flags: Flags to modify subprocess behaviour. + * + * Respawns the test program to run only @test_name in a subprocess. + * This can be used for a test case that might not return, or that + * might abort. @test_name will normally be the name of the parent + * test, followed by "/subprocess/" and then a name + * for the specific subtest (or just ending with + * "/subprocess" if the test only has one child + * test); tests with names of this form will automatically be skipped + * in the parent process. + * + * If @usec_timeout is non-0, the test subprocess is aborted and + * considered failing if its run time exceeds it. + * + * The subprocess behavior can be configured with the + * #GTestSubprocessFlags flags. + * + * You can use methods such as g_test_trap_assert_passed(), + * g_test_trap_assert_failed(), and g_test_trap_assert_stderr() to + * check the results of the subprocess. (But note that + * g_test_trap_assert_stdout() and g_test_trap_assert_stderr() + * cannot be used if @test_flags specifies that the child should + * inherit the parent stdout/stderr.) + * + * If your main () needs to behave differently in + * the subprocess, you can call g_test_subprocess() (after calling + * g_test_init()) to see whether you are in a subprocess. + * + * The following example tests that calling + * my_object_new(1000000) will abort with an error + * message. + * + * |[ + * static void + * test_create_large_object_subprocess (void) + * { + * my_object_new (1000000); + * } + * + * static void + * test_create_large_object (void) + * { + * g_test_trap_subprocess ("/myobject/create_large_object/subprocess", 0, 0); + * g_test_trap_assert_failed (); + * g_test_trap_assert_stderr ("*ERROR*too large*"); + * } + * + * int + * main (int argc, char **argv) + * { + * g_test_init (&argc, &argv, NULL); + * + * g_test_add_func ("/myobject/create_large_object", + * test_create_large_object); + * /* Because of the '/subprocess' in the name, this test will + * * not be run by the g_test_run () call below. + * */ + * g_test_add_func ("/myobject/create_large_object/subprocess", + * test_create_large_object_subprocess); + * + * return g_test_run (); + * } + * ]| + * + * Since: 2.38 + */ + + /** * g_test_undefined: * * Returns %TRUE if tests may provoke assertions and other formally-undefined - * behaviour under g_test_trap_fork(), to verify that appropriate warnings - * are given. It can be useful to turn this off if running tests under - * valgrind. + * behaviour, to verify that appropriate warnings are given. It might, in some + * cases, be useful to turn this off if running tests under valgrind. * * Returns: %TRUE if tests may provoke programming errors */ diff --git a/gir/gobject-2.0.c b/gir/gobject-2.0.c index 46402f8a..59892f03 100644 --- a/gir/gobject-2.0.c +++ b/gir/gobject-2.0.c @@ -5204,7 +5204,8 @@ * Sort @value_array using @compare_func to compare the elements according to * the semantics of #GCompareFunc. * - * The current implementation uses Quick-Sort as sorting algorithm. + * The current implementation uses the same sorting algorithm as standard + * C qsort() function. * * Returns: (transfer none): the #GValueArray passed in as @value_array * Deprecated: 2.32: Use #GArray and g_array_sort(). @@ -5220,7 +5221,8 @@ * Sort @value_array using @compare_func to compare the elements according * to the semantics of #GCompareDataFunc. * - * The current implementation uses Quick-Sort as sorting algorithm. + * The current implementation uses the same sorting algorithm as standard + * C qsort() function. * * Rename to: g_value_array_sort * Returns: (transfer none): the #GValueArray passed in as @value_array -- cgit v1.2.1