glib/auto/

key_file.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::{Bytes, Error, KeyFileFlags, ffi, translate::*};

crate::wrapper! {
    /// data), data_len);
    /// ```text
    ///
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct KeyFile(Shared<ffi::GKeyFile>);

    match fn {
        ref => |ptr| ffi::g_key_file_ref(ptr),
        unref => |ptr| ffi::g_key_file_unref(ptr),
        type_ => || ffi::g_key_file_get_type(),
    }
}

impl KeyFile {
    /// Creates a new empty [`KeyFile`][crate::KeyFile] object.
    ///
    /// Use [`load_from_file()`][Self::load_from_file()],
    /// [`load_from_data()`][Self::load_from_data()], [`load_from_dirs()`][Self::load_from_dirs()] or
    /// [`load_from_data_dirs()`][Self::load_from_data_dirs()] to
    /// read an existing key file.
    ///
    /// # Returns
    ///
    /// an empty [`KeyFile`][crate::KeyFile].
    #[doc(alias = "g_key_file_new")]
    pub fn new() -> KeyFile {
        unsafe { from_glib_full(ffi::g_key_file_new()) }
    }

    /// Retrieves a comment above @key from @group_name.
    ///
    /// If @key is `NULL` then @comment will be read from above
    /// @group_name. If both @key and @group_name are `NULL`, then
    /// @comment will be read from above the first group in the file.
    ///
    /// Note that the returned string does not include the `#` comment markers,
    /// but does include any whitespace after them (on each line). It includes
    /// the line breaks between lines, but does not include the final line break.
    /// ## `group_name`
    /// a group name, or `NULL` to get a top-level comment
    /// ## `key`
    /// a key, or `NULL` to get a group comment
    ///
    /// # Returns
    ///
    /// a comment that should be freed with `free()`
    #[doc(alias = "g_key_file_get_comment")]
    #[doc(alias = "get_comment")]
    pub fn comment(
        &self,
        group_name: Option<&str>,
        key: Option<&str>,
    ) -> Result<crate::GString, crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_key_file_get_comment(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the value associated with @key under @group_name as a double.
    ///
    /// If @key cannot be found then [error@GLib.KeyFileError.KEY_NOT_FOUND] is
    /// returned. Likewise, if the value associated with @key cannot be interpreted
    /// as a double then [error@GLib.KeyFileError.INVALID_VALUE] is returned.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    /// the value associated with the key as a double, or
    ///     `0.0` if the key was not found or could not be parsed.
    #[doc(alias = "g_key_file_get_double")]
    #[doc(alias = "get_double")]
    pub fn double(&self, group_name: &str, key: &str) -> Result<f64, crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_key_file_get_double(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(ret)
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the values associated with @key under @group_name as
    /// doubles.
    ///
    /// If @key cannot be found then [error@GLib.KeyFileError.KEY_NOT_FOUND] is
    /// returned. Likewise, if the values associated with @key cannot be interpreted
    /// as doubles then [error@GLib.KeyFileError.INVALID_VALUE] is returned.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    ///
    ///     the values associated with the key as a list of doubles, or `NULL` if the
    ///     key was not found or could not be parsed. The returned list of doubles
    ///     should be freed with `free()` when no longer needed.
    #[doc(alias = "g_key_file_get_double_list")]
    #[doc(alias = "get_double_list")]
    pub fn double_list(&self, group_name: &str, key: &str) -> Result<Vec<f64>, crate::Error> {
        unsafe {
            let mut length = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_key_file_get_double_list(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                length.as_mut_ptr(),
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibContainer::from_glib_container_num(
                    ret,
                    length.assume_init() as _,
                ))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the value associated with @key under @group_name as a signed
    /// 64-bit integer.
    ///
    /// This is similar to [`integer()`][Self::integer()] but can return
    /// 64-bit results without truncation.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    /// the value associated with the key as a signed 64-bit integer, or
    ///    `0` if the key was not found or could not be parsed.
    #[doc(alias = "g_key_file_get_int64")]
    #[doc(alias = "get_int64")]
    pub fn int64(&self, group_name: &str, key: &str) -> Result<i64, crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_key_file_get_int64(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(ret)
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the value associated with @key under @group_name as an
    /// integer.
    ///
    /// If @key cannot be found then [error@GLib.KeyFileError.KEY_NOT_FOUND] is
    /// returned. Likewise, if the value associated with @key cannot be interpreted
    /// as an integer, or is out of range for a `gint`, then
    /// [error@GLib.KeyFileError.INVALID_VALUE] is returned.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    /// the value associated with the key as an integer, or
    ///     `0` if the key was not found or could not be parsed.
    #[doc(alias = "g_key_file_get_integer")]
    #[doc(alias = "get_integer")]
    pub fn integer(&self, group_name: &str, key: &str) -> Result<i32, crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_key_file_get_integer(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(ret)
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the values associated with @key under @group_name as
    /// integers.
    ///
    /// If @key cannot be found then [error@GLib.KeyFileError.KEY_NOT_FOUND] is
    /// returned. Likewise, if the values associated with @key cannot be interpreted
    /// as integers, or are out of range for `gint`, then
    /// [error@GLib.KeyFileError.INVALID_VALUE] is returned.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    ///
    ///     the values associated with the key as a list of integers, or `NULL` if
    ///     the key was not found or could not be parsed. The returned list of
    ///     integers should be freed with `free()` when no longer needed.
    #[doc(alias = "g_key_file_get_integer_list")]
    #[doc(alias = "get_integer_list")]
    pub fn integer_list(&self, group_name: &str, key: &str) -> Result<Vec<i32>, crate::Error> {
        unsafe {
            let mut length = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_key_file_get_integer_list(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                length.as_mut_ptr(),
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibContainer::from_glib_container_num(
                    ret,
                    length.assume_init() as _,
                ))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the actual locale which the result of
    /// [`locale_string()`][Self::locale_string()] or
    /// [`locale_string_list()`][Self::locale_string_list()] came from.
    ///
    /// If calling [`locale_string()`][Self::locale_string()] or
    /// [`locale_string_list()`][Self::locale_string_list()] with exactly the same @self,
    /// @group_name, @key and @locale, the result of those functions will
    /// have originally been tagged with the locale that is the result of
    /// this function.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    /// ## `locale`
    /// a locale identifier or `NULL` to use the current locale
    ///
    /// # Returns
    ///
    /// the locale from the file, or `NULL` if the key was not
    ///   found or the entry in the file was was untranslated
    #[doc(alias = "g_key_file_get_locale_for_key")]
    #[doc(alias = "get_locale_for_key")]
    pub fn locale_for_key(
        &self,
        group_name: &str,
        key: &str,
        locale: Option<&str>,
    ) -> Option<crate::GString> {
        unsafe {
            from_glib_full(ffi::g_key_file_get_locale_for_key(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                locale.to_glib_none().0,
            ))
        }
    }

    /// Returns the name of the start group of the file.
    ///
    /// # Returns
    ///
    /// The start group of the key file.
    #[doc(alias = "g_key_file_get_start_group")]
    #[doc(alias = "get_start_group")]
    pub fn start_group(&self) -> Option<crate::GString> {
        unsafe { from_glib_full(ffi::g_key_file_get_start_group(self.to_glib_none().0)) }
    }

    /// Returns the value associated with @key under @group_name as an unsigned
    /// 64-bit integer.
    ///
    /// This is similar to [`integer()`][Self::integer()] but can return
    /// large positive results without truncation.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    /// the value associated with the key as an unsigned 64-bit integer,
    ///    or `0` if the key was not found or could not be parsed.
    #[doc(alias = "g_key_file_get_uint64")]
    #[doc(alias = "get_uint64")]
    pub fn uint64(&self, group_name: &str, key: &str) -> Result<u64, crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_key_file_get_uint64(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(ret)
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns the raw value associated with @key under @group_name.
    ///
    /// Use [`string()`][Self::string()] to retrieve an unescaped UTF-8 string.
    ///
    /// If the key cannot be found, [error@GLib.KeyFileError.KEY_NOT_FOUND]
    /// is returned.  If the @group_name cannot be found,
    /// [error@GLib.KeyFileError.GROUP_NOT_FOUND] is returned.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    /// a newly allocated string or `NULL` if the specified
    ///  key cannot be found.
    #[doc(alias = "g_key_file_get_value")]
    #[doc(alias = "get_value")]
    pub fn value(&self, group_name: &str, key: &str) -> Result<crate::GString, crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_key_file_get_value(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Looks whether the key file has the group @group_name.
    /// ## `group_name`
    /// a group name
    ///
    /// # Returns
    ///
    /// true if @group_name is a part of @self, false otherwise.
    #[doc(alias = "g_key_file_has_group")]
    pub fn has_group(&self, group_name: &str) -> bool {
        unsafe {
            from_glib(ffi::g_key_file_has_group(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
            ))
        }
    }

    /// Loads a key file from the data in @bytes into an empty [`KeyFile`][crate::KeyFile]
    /// structure.
    ///
    /// If the object cannot be created then a [`KeyFileError`][crate::KeyFileError] is returned.
    /// ## `bytes`
    /// a [`Bytes`][crate::Bytes]
    /// ## `flags`
    /// flags from [`KeyFileFlags`][crate::KeyFileFlags]
    ///
    /// # Returns
    ///
    /// true if a key file could be loaded, false otherwise
    #[doc(alias = "g_key_file_load_from_bytes")]
    pub fn load_from_bytes(&self, bytes: &Bytes, flags: KeyFileFlags) -> Result<(), crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_key_file_load_from_bytes(
                self.to_glib_none().0,
                bytes.to_glib_none().0,
                flags.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Loads a key file from memory into an empty [`KeyFile`][crate::KeyFile] structure.
    ///
    /// If the object cannot be created then a [`KeyFileError`][crate::KeyFileError] is returned.
    /// ## `data`
    /// key file loaded in memory
    /// ## `length`
    /// the length of @data in bytes (or `(gsize)-1` if data is nul-terminated)
    /// ## `flags`
    /// flags from [`KeyFileFlags`][crate::KeyFileFlags]
    ///
    /// # Returns
    ///
    /// true if a key file could be loaded, false otherwise
    #[doc(alias = "g_key_file_load_from_data")]
    pub fn load_from_data(&self, data: &str, flags: KeyFileFlags) -> Result<(), crate::Error> {
        let length = data.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_key_file_load_from_data(
                self.to_glib_none().0,
                data.to_glib_none().0,
                length,
                flags.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Loads a key file into an empty [`KeyFile`][crate::KeyFile] structure.
    ///
    /// If the OS returns an error when opening or reading the file, a
    /// [`FileError`][crate::FileError] is returned. If there is a problem parsing the file,
    /// a [`KeyFileError`][crate::KeyFileError] is returned.
    ///
    /// This function will never return a [error@GLib.KeyFileError.NOT_FOUND]
    /// error. If the @file is not found, [error@GLib.FileError.NOENT] is returned.
    /// ## `file`
    /// the path of a filename to load, in the GLib filename encoding
    /// ## `flags`
    /// flags from [`KeyFileFlags`][crate::KeyFileFlags]
    ///
    /// # Returns
    ///
    /// true if a key file could be loaded, false otherwise
    #[doc(alias = "g_key_file_load_from_file")]
    pub fn load_from_file(
        &self,
        file: impl AsRef<std::path::Path>,
        flags: KeyFileFlags,
    ) -> Result<(), crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_key_file_load_from_file(
                self.to_glib_none().0,
                file.as_ref().to_glib_none().0,
                flags.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Removes a comment above @key from @group_name.
    ///
    /// If @key is `NULL` then @comment will be removed above @group_name.
    /// If both @key and @group_name are `NULL`, then @comment will
    /// be removed above the first group in the file.
    /// ## `group_name`
    /// a group name, or `NULL` to get a top-level comment
    /// ## `key`
    /// a key, or `NULL` to get a group comment
    ///
    /// # Returns
    ///
    /// true if the comment was removed, false otherwise
    #[doc(alias = "g_key_file_remove_comment")]
    pub fn remove_comment(
        &self,
        group_name: Option<&str>,
        key: Option<&str>,
    ) -> Result<(), crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_key_file_remove_comment(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Removes the specified group, @group_name,
    /// from the key file.
    /// ## `group_name`
    /// a group name
    ///
    /// # Returns
    ///
    /// true if the group was removed, false otherwise
    #[doc(alias = "g_key_file_remove_group")]
    pub fn remove_group(&self, group_name: &str) -> Result<(), crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_key_file_remove_group(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Removes @key in @group_name from the key file.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key name to remove
    ///
    /// # Returns
    ///
    /// true if the key was removed, false otherwise
    #[doc(alias = "g_key_file_remove_key")]
    pub fn remove_key(&self, group_name: &str, key: &str) -> Result<(), crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_key_file_remove_key(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Associates a new boolean value with @key under @group_name.
    ///
    /// If @key cannot be found then it is created.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    /// ## `value`
    /// true or false
    #[doc(alias = "g_key_file_set_boolean")]
    pub fn set_boolean(&self, group_name: &str, key: &str, value: bool) {
        unsafe {
            ffi::g_key_file_set_boolean(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                value.into_glib(),
            );
        }
    }

    //#[doc(alias = "g_key_file_set_boolean_list")]
    //pub fn set_boolean_list(&self, group_name: &str, key: &str, list: /*Unimplemented*/&CArray TypeId { ns_id: 0, id: 1 }) {
    //    unsafe { TODO: call ffi:g_key_file_set_boolean_list() }
    //}

    /// Places a comment above @key from @group_name.
    ///
    /// If @key is `NULL` then @comment will be written above @group_name.
    /// If both @key and @group_name are `NULL`, then @comment will be
    /// written above the first group in the file.
    ///
    /// Passing a non-existent @group_name or @key to this function returns
    /// false and populates @error. (In contrast, passing a non-existent
    /// `group_name` or `key` to [`set_string()`][Self::set_string()]
    /// creates the associated group name and key.)
    ///
    /// Note that this function prepends a `#` comment marker to
    /// each line of @comment.
    /// ## `group_name`
    /// a group name, or `NULL` to write a top-level comment
    /// ## `key`
    /// a key, or `NULL` to write a group comment
    /// ## `comment`
    /// a comment
    ///
    /// # Returns
    ///
    /// true if the comment was written, false otherwise
    #[doc(alias = "g_key_file_set_comment")]
    pub fn set_comment(
        &self,
        group_name: Option<&str>,
        key: Option<&str>,
        comment: &str,
    ) -> Result<(), crate::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_key_file_set_comment(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                comment.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Associates a new double value with @key under @group_name.
    ///
    /// If @key cannot be found then it is created.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    /// ## `value`
    /// a double value
    #[doc(alias = "g_key_file_set_double")]
    pub fn set_double(&self, group_name: &str, key: &str, value: f64) {
        unsafe {
            ffi::g_key_file_set_double(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                value,
            );
        }
    }

    /// Associates a new integer value with @key under @group_name.
    ///
    /// If @key cannot be found then it is created.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    /// ## `value`
    /// an integer value
    #[doc(alias = "g_key_file_set_int64")]
    pub fn set_int64(&self, group_name: &str, key: &str, value: i64) {
        unsafe {
            ffi::g_key_file_set_int64(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                value,
            );
        }
    }

    /// Associates a new integer value with @key under @group_name.
    ///
    /// If @key cannot be found then it is created.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    /// ## `value`
    /// an integer value
    #[doc(alias = "g_key_file_set_integer")]
    pub fn set_integer(&self, group_name: &str, key: &str, value: i32) {
        unsafe {
            ffi::g_key_file_set_integer(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                value,
            );
        }
    }

    /// Sets the character which is used to separate values in lists.
    ///
    /// Typically `;` or `,` are used as separators. The default list separator
    /// is `;`.
    /// ## `separator`
    /// the separator
    #[doc(alias = "g_key_file_set_list_separator")]
    pub fn set_list_separator(&self, separator: crate::Char) {
        unsafe {
            ffi::g_key_file_set_list_separator(self.to_glib_none().0, separator.into_glib());
        }
    }

    /// Associates a string value for @key and @locale under @group_name.
    ///
    /// If the translation for @key cannot be found then it is created.
    ///
    /// If @locale is `C` then the untranslated value is set (since GLib 2.84).
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    /// ## `locale`
    /// a locale identifier
    /// ## `string`
    /// a string
    #[doc(alias = "g_key_file_set_locale_string")]
    pub fn set_locale_string(&self, group_name: &str, key: &str, locale: &str, string: &str) {
        unsafe {
            ffi::g_key_file_set_locale_string(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                locale.to_glib_none().0,
                string.to_glib_none().0,
            );
        }
    }

    /// Associates a new string value with @key under @group_name.
    ///
    /// If @key cannot be found then it is created.
    /// If @group_name cannot be found then it is created.
    /// Unlike [`set_value()`][Self::set_value()], this function handles characters
    /// that need escaping, such as newlines.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    /// ## `string`
    /// a string
    #[doc(alias = "g_key_file_set_string")]
    pub fn set_string(&self, group_name: &str, key: &str, string: &str) {
        unsafe {
            ffi::g_key_file_set_string(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                string.to_glib_none().0,
            );
        }
    }

    /// Associates a new integer value with @key under @group_name.
    ///
    /// If @key cannot be found then it is created.
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    /// ## `value`
    /// an integer value
    #[doc(alias = "g_key_file_set_uint64")]
    pub fn set_uint64(&self, group_name: &str, key: &str, value: u64) {
        unsafe {
            ffi::g_key_file_set_uint64(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                value,
            );
        }
    }

    /// Associates a new value with @key under @group_name.
    ///
    /// If @key cannot be found then it is created. If @group_name cannot
    /// be found then it is created. To set an UTF-8 string which may contain
    /// characters that need escaping (such as newlines or spaces), use
    /// [`set_string()`][Self::set_string()].
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    /// ## `value`
    /// a string
    #[doc(alias = "g_key_file_set_value")]
    pub fn set_value(&self, group_name: &str, key: &str, value: &str) {
        unsafe {
            ffi::g_key_file_set_value(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                value.to_glib_none().0,
            );
        }
    }
}

impl Default for KeyFile {
    fn default() -> Self {
        Self::new()
    }
}