nm_rs/auto/

remote_connection.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir
// from gtk-girs (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT
#![allow(deprecated)]

use crate::{ffi,Connection,Object};
#[cfg(feature = "v1_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
use crate::{SettingsConnectionFlags};
use glib::{prelude::*,signal::{connect_raw, SignalHandlerId},translate::*};
use std::{boxed::Box as Box_,pin::Pin};

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `filename`
    ///  File that stores the connection in case the connection is
    /// file-backed.
    ///
    /// Readable
    ///
    ///
    /// #### `flags`
    ///  The flags of the connection as unsigned integer. The values
    /// correspond to the #NMSettingsConnectionFlags enum.
    ///
    /// Readable
    ///
    ///
    /// #### `unsaved`
    ///  [`true`] if the remote connection contains changes that have not been saved
    /// to disk, [`false`] if the connection is the same as its on-disk representation.
    ///
    /// Readable
    ///
    ///
    /// #### `version-id`
    ///  The version ID of the profile that is incremented when the profile gets modified.
    /// This can be used to track concurrent modifications of the profile.
    ///
    /// Readable
    ///
    ///
    /// #### `visible`
    ///  [`true`] if the remote connection is visible to the current user, [`false`] if
    /// not.  If the connection is not visible then it is essentially useless; it
    /// will not contain any settings, and operations such as
    /// nm_remote_connection_save() and nm_remote_connection_delete() will always
    /// fail. (#NMRemoteSettings will not normally return non-visible connections
    /// to callers, but it is possible for a connection's visibility to change
    /// after you already have a reference to it.)
    ///
    /// Readable
    /// <details><summary><h4>Object</h4></summary>
    ///
    ///
    /// #### `client`
    ///  The NMClient instance as returned by nm_object_get_client().
    ///
    /// When an NMObject gets removed from the NMClient cache,
    /// the NMObject:path property stays unchanged, but this client
    /// instance gets reset to [`None`]. You can use this property to
    /// track removal of the object from the cache.
    ///
    /// Readable
    ///
    ///
    /// #### `path`
    ///  The D-Bus object path.
    ///
    /// The D-Bus path of an object instance never changes, even if the object
    /// gets removed from the cache. To see whether the object is still in the
    /// cache, check NMObject:client.
    ///
    /// Readable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`ObjectExt`][trait@crate::prelude::ObjectExt], [`ConnectionExt`][trait@crate::prelude::ConnectionExt]
    #[doc(alias = "NMRemoteConnection")]
    pub struct RemoteConnection(Object<ffi::NMRemoteConnection, ffi::NMRemoteConnectionClass>) @extends Object, @implements Connection;

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

impl RemoteConnection {
    /// Send any local changes to the settings and properties of @self to
    /// NetworkManager. If @save_to_disk is [`true`], the updated connection will be saved to
    /// disk; if [`false`], then only the in-memory representation will be changed.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use nm_remote_connection_commit_changes_async() or GDBusConnection.
    /// ## `save_to_disk`
    /// whether to persist the changes to disk
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error, in which case @error will be set.
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_remote_connection_commit_changes")]
    pub fn commit_changes(&self, save_to_disk: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_remote_connection_commit_changes(self.to_glib_none().0, save_to_disk.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
        }
    }

    /// Asynchronously sends any local changes to the settings and properties of
    /// @self to NetworkManager. If @save is [`true`], the updated connection will
    /// be saved to disk; if [`false`], then only the in-memory representation will be
    /// changed.
    /// ## `save_to_disk`
    /// whether to save the changes to persistent storage
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the commit operation completes
    #[doc(alias = "nm_remote_connection_commit_changes_async")]
    pub fn commit_changes_async<P: FnOnce(Result<(), glib::Error>) + 'static>(&self, save_to_disk: bool, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
        
                let main_context = glib::MainContext::ref_thread_default();
                let is_main_context_owner = main_context.is_owner();
                let has_acquired_main_context = (!is_main_context_owner)
                    .then(|| main_context.acquire().ok())
                    .flatten();
                assert!(
                    is_main_context_owner || has_acquired_main_context.is_some(),
                    "Async operations only allowed if the thread is owning the MainContext"
                );
        
        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn commit_changes_async_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(_source_object: *mut glib::gobject_ffi::GObject, res: *mut gio::ffi::GAsyncResult, user_data: glib::ffi::gpointer) {
            let mut error = std::ptr::null_mut();
            ffi::nm_remote_connection_commit_changes_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> = Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = commit_changes_async_trampoline::<P>;
        unsafe {
            ffi::nm_remote_connection_commit_changes_async(self.to_glib_none().0, save_to_disk.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, Some(callback), Box_::into_raw(user_data) as *mut _);
        }
    }

    
    pub fn commit_changes_future(&self, save_to_disk: bool) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {

        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.commit_changes_async(
                save_to_disk,
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    /// Deletes the connection.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use nm_remote_connection_delete_async() or GDBusConnection.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error, in which case @error will be set.
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_remote_connection_delete")]
    pub fn delete(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_remote_connection_delete(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
        }
    }

    /// Asynchronously deletes the connection.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the delete operation completes
    #[doc(alias = "nm_remote_connection_delete_async")]
    pub fn delete_async<P: FnOnce(Result<(), glib::Error>) + 'static>(&self, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
        
                let main_context = glib::MainContext::ref_thread_default();
                let is_main_context_owner = main_context.is_owner();
                let has_acquired_main_context = (!is_main_context_owner)
                    .then(|| main_context.acquire().ok())
                    .flatten();
                assert!(
                    is_main_context_owner || has_acquired_main_context.is_some(),
                    "Async operations only allowed if the thread is owning the MainContext"
                );
        
        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn delete_async_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(_source_object: *mut glib::gobject_ffi::GObject, res: *mut gio::ffi::GAsyncResult, user_data: glib::ffi::gpointer) {
            let mut error = std::ptr::null_mut();
            ffi::nm_remote_connection_delete_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> = Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = delete_async_trampoline::<P>;
        unsafe {
            ffi::nm_remote_connection_delete_async(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, Some(callback), Box_::into_raw(user_data) as *mut _);
        }
    }

    
    pub fn delete_future(&self) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {

        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.delete_async(
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    ///
    /// # Returns
    ///
    /// file that stores the connection in case the connection is file-backed.
    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "nm_remote_connection_get_filename")]
    #[doc(alias = "get_filename")]
    pub fn filename(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::nm_remote_connection_get_filename(self.to_glib_none().0))
        }
    }

    ///
    /// # Returns
    ///
    /// the flags of the connection of type #NMSettingsConnectionFlags.
    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "nm_remote_connection_get_flags")]
    #[doc(alias = "get_flags")]
    pub fn flags(&self) -> SettingsConnectionFlags {
        unsafe {
            from_glib(ffi::nm_remote_connection_get_flags(self.to_glib_none().0))
        }
    }

    //#[doc(alias = "nm_remote_connection_get_secrets")]
    //#[doc(alias = "get_secrets")]
    //pub fn secrets(&self, setting_name: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result</*Ignored*/glib::Variant, glib::Error> {
    //    unsafe { TODO: call ffi:nm_remote_connection_get_secrets() }
    //}

    //#[doc(alias = "nm_remote_connection_get_secrets_async")]
    //#[doc(alias = "get_secrets_async")]
    //pub fn secrets_async<P: FnOnce(Result</*Ignored*/glib::Variant, glib::Error>) + 'static>(&self, setting_name: &str, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
    //    unsafe { TODO: call ffi:nm_remote_connection_get_secrets_async() }
    //}

    //
    //pub fn secrets_future(&self, setting_name: &str) -> Pin<Box_<dyn std::future::Future<Output = Result</*Ignored*/glib::Variant, glib::Error>> + 'static>> {

        //let setting_name = String::from(setting_name);
        //Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
        //    obj.secrets_async(
        //        &setting_name,
        //        Some(cancellable),
        //        move |res| {
        //            send.resolve(res);
        //        },
        //    );
        //}))
    //}

    ///
    /// # Returns
    ///
    /// [`true`] if the remote connection contains changes that have not
    /// been saved to disk, [`false`] if the connection is the same as its on-disk
    /// representation.
    #[doc(alias = "nm_remote_connection_get_unsaved")]
    #[doc(alias = "get_unsaved")]
    #[doc(alias = "unsaved")]
    pub fn is_unsaved(&self) -> bool {
        unsafe {
            from_glib(ffi::nm_remote_connection_get_unsaved(self.to_glib_none().0))
        }
    }

    ///
    /// # Returns
    ///
    /// the version-id of the profile. This ID is incremented
    ///   whenever the profile is modified.
    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    #[doc(alias = "nm_remote_connection_get_version_id")]
    #[doc(alias = "get_version_id")]
    #[doc(alias = "version-id")]
    pub fn version_id(&self) -> u64 {
        unsafe {
            ffi::nm_remote_connection_get_version_id(self.to_glib_none().0)
        }
    }

    /// Checks if the connection is visible to the current user.  If the
    /// connection is not visible then it is essentially useless; it will
    /// not contain any settings, and operations such as
    /// nm_remote_connection_save() and nm_remote_connection_delete() will
    /// always fail. (#NMRemoteSettings will not normally return
    /// non-visible connections to callers, but it is possible for a
    /// connection's visibility to change after you already have a
    /// reference to it.)
    ///
    /// # Returns
    ///
    /// [`true`] if the remote connection is visible to the current
    /// user, [`false`] if not.
    #[doc(alias = "nm_remote_connection_get_visible")]
    #[doc(alias = "get_visible")]
    #[doc(alias = "visible")]
    pub fn is_visible(&self) -> bool {
        unsafe {
            from_glib(ffi::nm_remote_connection_get_visible(self.to_glib_none().0))
        }
    }

    /// Saves the connection to disk if the connection has changes that have not yet
    /// been written to disk, or if the connection has never been saved.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use nm_remote_connection_save_async() or GDBusConnection.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error, in which case @error will be set.
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_remote_connection_save")]
    pub fn save(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_remote_connection_save(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
        }
    }

    /// Saves the connection to disk if the connection has changes that have not yet
    /// been written to disk, or if the connection has never been saved.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the save operation completes
    #[doc(alias = "nm_remote_connection_save_async")]
    pub fn save_async<P: FnOnce(Result<(), glib::Error>) + 'static>(&self, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
        
                let main_context = glib::MainContext::ref_thread_default();
                let is_main_context_owner = main_context.is_owner();
                let has_acquired_main_context = (!is_main_context_owner)
                    .then(|| main_context.acquire().ok())
                    .flatten();
                assert!(
                    is_main_context_owner || has_acquired_main_context.is_some(),
                    "Async operations only allowed if the thread is owning the MainContext"
                );
        
        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn save_async_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(_source_object: *mut glib::gobject_ffi::GObject, res: *mut gio::ffi::GAsyncResult, user_data: glib::ffi::gpointer) {
            let mut error = std::ptr::null_mut();
            ffi::nm_remote_connection_save_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> = Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = save_async_trampoline::<P>;
        unsafe {
            ffi::nm_remote_connection_save_async(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, Some(callback), Box_::into_raw(user_data) as *mut _);
        }
    }

    
    pub fn save_future(&self) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {

        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.save_async(
                Some(cancellable),
                move |res| {
                    send.resolve(res);
                },
            );
        }))
    }

    //#[cfg(feature = "v1_12")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    //#[doc(alias = "nm_remote_connection_update2")]
    //pub fn update2<P: FnOnce(Result</*Ignored*/glib::Variant, glib::Error>) + 'static>(&self, settings: /*Ignored*/Option<&glib::Variant>, flags: SettingsUpdate2Flags, args: /*Ignored*/Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
    //    unsafe { TODO: call ffi:nm_remote_connection_update2() }
    //}

    //
    //#[cfg(feature = "v1_12")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    //pub fn update2_future(&self, settings: /*Ignored*/Option<&glib::Variant>, flags: SettingsUpdate2Flags, args: /*Ignored*/Option<&glib::Variant>) -> Pin<Box_<dyn std::future::Future<Output = Result</*Ignored*/glib::Variant, glib::Error>> + 'static>> {

        //let settings = settings.map(ToOwned::to_owned);
        //let args = args.map(ToOwned::to_owned);
        //Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
        //    obj.update2(
        //        settings.as_ref().map(::std::borrow::Borrow::borrow),
        //        flags,
        //        args.as_ref().map(::std::borrow::Borrow::borrow),
        //        Some(cancellable),
        //        move |res| {
        //            send.resolve(res);
        //        },
        //    );
        //}))
    //}

    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "filename")]
    pub fn connect_filename_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_filename_trampoline<F: Fn(&RemoteConnection) + 'static>(this: *mut ffi::NMRemoteConnection, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(self.as_ptr() as *mut _, c"notify::filename".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(notify_filename_trampoline::<F> as *const ())), Box_::into_raw(f))
        }
    }

    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "flags")]
    pub fn connect_flags_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_flags_trampoline<F: Fn(&RemoteConnection) + 'static>(this: *mut ffi::NMRemoteConnection, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(self.as_ptr() as *mut _, c"notify::flags".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(notify_flags_trampoline::<F> as *const ())), Box_::into_raw(f))
        }
    }

    #[doc(alias = "unsaved")]
    pub fn connect_unsaved_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_unsaved_trampoline<F: Fn(&RemoteConnection) + 'static>(this: *mut ffi::NMRemoteConnection, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(self.as_ptr() as *mut _, c"notify::unsaved".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(notify_unsaved_trampoline::<F> as *const ())), Box_::into_raw(f))
        }
    }

    #[cfg(feature = "v1_44")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))]
    #[doc(alias = "version-id")]
    pub fn connect_version_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_version_id_trampoline<F: Fn(&RemoteConnection) + 'static>(this: *mut ffi::NMRemoteConnection, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(self.as_ptr() as *mut _, c"notify::version-id".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(notify_version_id_trampoline::<F> as *const ())), Box_::into_raw(f))
        }
    }

    #[doc(alias = "visible")]
    pub fn connect_visible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_visible_trampoline<F: Fn(&RemoteConnection) + 'static>(this: *mut ffi::NMRemoteConnection, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(self.as_ptr() as *mut _, c"notify::visible".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(notify_visible_trampoline::<F> as *const ())), Box_::into_raw(f))
        }
    }
}