gio/auto/

dbus_object_manager_server.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{ffi, DBusConnection, DBusObjectManager, DBusObjectSkeleton};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// `GDBusObjectManagerServer` is used to export [`DBusObject`][crate::DBusObject] instances
    /// using the standardized
    /// [`org.freedesktop.DBus.ObjectManager`](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
    /// interface. For example, remote D-Bus clients can get all objects
    /// and properties in a single call. Additionally, any change in the
    /// object hierarchy is broadcast using signals. This means that D-Bus
    /// clients can keep caches up to date by only listening to D-Bus
    /// signals.
    ///
    /// The recommended path to export an object manager at is the path form of the
    /// well-known name of a D-Bus service, or below. For example, if a D-Bus service
    /// is available at the well-known name `net.example.ExampleService1`, the object
    /// manager should typically be exported at `/net/example/ExampleService1`, or
    /// below (to allow for multiple object managers in a service).
    ///
    /// It is supported, but not recommended, to export an object manager at the root
    /// path, `/`.
    ///
    /// See `Gio::DBusObjectManagerClient` for the client-side code that is
    /// intended to be used with `GDBusObjectManagerServer` or any D-Bus
    /// object implementing the `org.freedesktop.DBus.ObjectManager` interface.
    ///
    /// ## Properties
    ///
    ///
    /// #### `connection`
    ///  The #GDBusConnection to export objects on.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `object-path`
    ///  The object path to register the manager object at.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// # Implements
    ///
    /// [`DBusObjectManagerServerExt`][trait@crate::prelude::DBusObjectManagerServerExt], [`trait@glib::ObjectExt`], [`DBusObjectManagerExt`][trait@crate::prelude::DBusObjectManagerExt]
    #[doc(alias = "GDBusObjectManagerServer")]
    pub struct DBusObjectManagerServer(Object<ffi::GDBusObjectManagerServer, ffi::GDBusObjectManagerServerClass>) @implements DBusObjectManager;

    match fn {
        type_ => || ffi::g_dbus_object_manager_server_get_type(),
    }
}

impl DBusObjectManagerServer {
    pub const NONE: Option<&'static DBusObjectManagerServer> = None;

    /// Creates a new #GDBusObjectManagerServer object.
    ///
    /// The returned server isn't yet exported on any connection. To do so,
    /// use g_dbus_object_manager_server_set_connection(). Normally you
    /// want to export all of your objects before doing so to avoid
    /// [InterfacesAdded](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
    /// signals being emitted.
    /// ## `object_path`
    /// The object path to export the manager object at.
    ///
    /// # Returns
    ///
    /// A #GDBusObjectManagerServer object. Free with g_object_unref().
    #[doc(alias = "g_dbus_object_manager_server_new")]
    pub fn new(object_path: &str) -> DBusObjectManagerServer {
        unsafe {
            from_glib_full(ffi::g_dbus_object_manager_server_new(
                object_path.to_glib_none().0,
            ))
        }
    }
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::DBusObjectManagerServer>> Sealed for T {}
}

/// Trait containing all [`struct@DBusObjectManagerServer`] methods.
///
/// # Implementors
///
/// [`DBusObjectManagerServer`][struct@crate::DBusObjectManagerServer]
pub trait DBusObjectManagerServerExt:
    IsA<DBusObjectManagerServer> + sealed::Sealed + 'static
{
    /// Exports @object on @self.
    ///
    /// If there is already a #GDBusObject exported at the object path,
    /// then the old object is removed.
    ///
    /// The object path for @object must be in the hierarchy rooted by the
    /// object path for @self.
    ///
    /// Note that @self will take a reference on @object for as long as
    /// it is exported.
    /// ## `object`
    /// A #GDBusObjectSkeleton.
    #[doc(alias = "g_dbus_object_manager_server_export")]
    fn export(&self, object: &impl IsA<DBusObjectSkeleton>) {
        unsafe {
            ffi::g_dbus_object_manager_server_export(
                self.as_ref().to_glib_none().0,
                object.as_ref().to_glib_none().0,
            );
        }
    }

    /// Like g_dbus_object_manager_server_export() but appends a string of
    /// the form _N (with N being a natural number) to @object's object path
    /// if an object with the given path already exists. As such, the
    /// #GDBusObjectProxy:g-object-path property of @object may be modified.
    /// ## `object`
    /// An object.
    #[doc(alias = "g_dbus_object_manager_server_export_uniquely")]
    fn export_uniquely(&self, object: &impl IsA<DBusObjectSkeleton>) {
        unsafe {
            ffi::g_dbus_object_manager_server_export_uniquely(
                self.as_ref().to_glib_none().0,
                object.as_ref().to_glib_none().0,
            );
        }
    }

    /// Gets the #GDBusConnection used by @self.
    ///
    /// # Returns
    ///
    /// A #GDBusConnection object or [`None`] if
    ///   @self isn't exported on a connection. The returned object should
    ///   be freed with g_object_unref().
    #[doc(alias = "g_dbus_object_manager_server_get_connection")]
    #[doc(alias = "get_connection")]
    fn connection(&self) -> Option<DBusConnection> {
        unsafe {
            from_glib_full(ffi::g_dbus_object_manager_server_get_connection(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether @object is currently exported on @self.
    /// ## `object`
    /// An object.
    ///
    /// # Returns
    ///
    /// [`true`] if @object is exported
    #[doc(alias = "g_dbus_object_manager_server_is_exported")]
    fn is_exported(&self, object: &impl IsA<DBusObjectSkeleton>) -> bool {
        unsafe {
            from_glib(ffi::g_dbus_object_manager_server_is_exported(
                self.as_ref().to_glib_none().0,
                object.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Exports all objects managed by @self on @connection. If
    /// @connection is [`None`], stops exporting objects.
    /// ## `connection`
    /// A #GDBusConnection or [`None`].
    #[doc(alias = "g_dbus_object_manager_server_set_connection")]
    #[doc(alias = "connection")]
    fn set_connection(&self, connection: Option<&DBusConnection>) {
        unsafe {
            ffi::g_dbus_object_manager_server_set_connection(
                self.as_ref().to_glib_none().0,
                connection.to_glib_none().0,
            );
        }
    }

    /// If @self has an object at @path, removes the object. Otherwise
    /// does nothing.
    ///
    /// Note that @object_path must be in the hierarchy rooted by the
    /// object path for @self.
    /// ## `object_path`
    /// An object path.
    ///
    /// # Returns
    ///
    /// [`true`] if object at @object_path was removed, [`false`] otherwise.
    #[doc(alias = "g_dbus_object_manager_server_unexport")]
    fn unexport(&self, object_path: &str) -> bool {
        unsafe {
            from_glib(ffi::g_dbus_object_manager_server_unexport(
                self.as_ref().to_glib_none().0,
                object_path.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "connection")]
    fn connect_connection_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_connection_trampoline<
            P: IsA<DBusObjectManagerServer>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDBusObjectManagerServer,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(DBusObjectManagerServer::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::connection\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_connection_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<DBusObjectManagerServer>> DBusObjectManagerServerExt for O {}