nm_rs/auto/

setting_user.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

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

glib::wrapper! {
    /// General User Profile Settings
    ///
    /// ## Properties
    ///
    ///
    /// #### `data`
    ///  A dictionary of key/value pairs with user data. This data is ignored by NetworkManager
    /// and can be used at the users discretion. The keys only support a strict ascii format,
    /// but the values can be arbitrary UTF8 strings up to a certain length.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Setting</h4></summary>
    ///
    ///
    /// #### `name`
    ///  The setting's name, which uniquely identifies the setting within the
    /// connection.  Each setting type has a name unique to that type, for
    /// example "ppp" or "802-11-wireless" or "802-3-ethernet".
    ///
    /// Readable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`SettingExt`][trait@crate::prelude::SettingExt]
    #[doc(alias = "NMSettingUser")]
    pub struct SettingUser(Object<ffi::NMSettingUser, ffi::NMSettingUserClass>) @extends Setting;

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

impl SettingUser {
    /// Creates a new #NMSettingUser object with default values.
    ///
    /// # Returns
    ///
    /// the new empty #NMSettingUser object
    #[doc(alias = "nm_setting_user_new")]
    pub fn new() -> SettingUser {
        assert_initialized_main_thread!();
        unsafe {
            Setting::from_glib_full(ffi::nm_setting_user_new()).unsafe_cast()
        }
    }

            // rustdoc-stripper-ignore-next
            /// Creates a new builder-pattern struct instance to construct [`SettingUser`] objects.
            ///
            /// This method returns an instance of [`SettingUserBuilder`](crate::builders::SettingUserBuilder) which can be used to create [`SettingUser`] objects.
            pub fn builder() -> SettingUserBuilder {
                SettingUserBuilder::new()
            }
        

    /// ## `key`
    /// the key to lookup
    ///
    /// # Returns
    ///
    /// the value associated with @key or [`None`] if no such
    ///   value exists.
    #[doc(alias = "nm_setting_user_get_data")]
    #[doc(alias = "get_data")]
    pub fn data(&self, key: &str) -> glib::GString {
        unsafe {
            from_glib_none(ffi::nm_setting_user_get_data(self.to_glib_none().0, key.to_glib_none().0))
        }
    }

    ///
    /// # Returns
    ///
    /// a
    ///   [`None`]-terminated array containing each key from the table.
    #[doc(alias = "nm_setting_user_get_keys")]
    #[doc(alias = "get_keys")]
    pub fn keys(&self) -> Vec<glib::GString> {
        unsafe {
            let mut out_len = std::mem::MaybeUninit::uninit();
            let ret = FromGlibContainer::from_glib_none_num(ffi::nm_setting_user_get_keys(self.to_glib_none().0, out_len.as_mut_ptr()), out_len.assume_init() as _);
            ret
        }
    }

    /// ## `key`
    /// the key to set
    /// ## `val`
    /// the value to set or [`None`] to clear a key.
    ///
    /// # Returns
    ///
    /// [`true`] if the operation was successful. The operation
    ///   can fail if @key or @val are not valid strings according
    ///   to nm_setting_user_check_key() and nm_setting_user_check_val().
    #[doc(alias = "nm_setting_user_set_data")]
    #[doc(alias = "data")]
    pub fn set_data(&self, key: &str, val: Option<&str>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_setting_user_set_data(self.to_glib_none().0, key.to_glib_none().0, val.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)) }
        }
    }

    /// Checks whether @key is a valid user data key. This means,
    /// key is not [`None`], not too large and valid ASCII. Also,
    /// only digits and numbers are allowed with a few special
    /// characters. The key must contain at least one '.' and
    /// look like a fully qualified DNS name.
    /// ## `key`
    /// the key to check
    ///
    /// # Returns
    ///
    /// [`true`] if @key is a valid user data key.
    #[doc(alias = "nm_setting_user_check_key")]
    pub fn check_key(key: &str) -> Result<(), glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_setting_user_check_key(key.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)) }
        }
    }

    /// Checks whether @val is a valid user data value. This means,
    /// value is not [`None`], not too large and valid UTF-8.
    /// ## `val`
    /// the value to check
    ///
    /// # Returns
    ///
    /// [`true`] if @val is a valid user data value.
    #[doc(alias = "nm_setting_user_check_val")]
    pub fn check_val(val: &str) -> Result<(), glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_setting_user_check_val(val.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)) }
        }
    }

    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    #[doc(alias = "data")]
    pub fn connect_data_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_data_trampoline<F: Fn(&SettingUser) + 'static>(this: *mut ffi::NMSettingUser, _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::data".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(notify_data_trampoline::<F> as *const ())), Box_::into_raw(f))
        }
    }
}

#[cfg(feature = "v1_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
impl Default for SettingUser {
                     fn default() -> Self {
                         Self::new()
                     }
                 }

// rustdoc-stripper-ignore-next
        /// A [builder-pattern] type to construct [`SettingUser`] objects.
        ///
        /// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct SettingUserBuilder {
            builder: glib::object::ObjectBuilder<'static, SettingUser>,
        }

        impl SettingUserBuilder {
        fn new() -> Self {
            Self { builder: glib::object::Object::builder() }
        }

                        //    #[cfg(feature = "v1_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_8")))]
    //pub fn data(self, data: /*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 }) -> Self {
                        //    Self { builder: self.builder.property("data", data), }
                        //}

    // rustdoc-stripper-ignore-next
    /// Build the [`SettingUser`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> SettingUser {
assert_initialized_main_thread!();
    self.builder.build() }
}