// 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::translate::*;
#[cfg(any(feature = "v2_50", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_50")))]
use crate::Bytes;
use crate::Error;
use crate::KeyFileFlags;
use std::mem;
use std::ptr;

crate::wrapper! {
    /// The GKeyFile struct contains only private data
    /// and should not be accessed directly.
    #[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 [`None`] then `comment` will be read from above
    /// `group_name`. If both `key` and `group_name` are [`None`], 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 [`None`]
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    /// a comment that should be freed with `g_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 = 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 `group_name` is [`None`], the start_group is used.
    ///
    /// If `key` cannot be found then 0.0 is returned and `error` is set to
    /// [`KeyFileError::KeyNotFound`][crate::KeyFileError::KeyNotFound]. Likewise, if the value associated
    /// with `key` cannot be interpreted as a double then 0.0 is returned
    /// and `error` is set to [`KeyFileError::InvalidValue`][crate::KeyFileError::InvalidValue].
    /// ## `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 = 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 [`None`] is returned and `error` is set to
    /// [`KeyFileError::KeyNotFound`][crate::KeyFileError::KeyNotFound]. Likewise, if the values associated
    /// with `key` cannot be interpreted as doubles then [`None`] is returned
    /// and `error` is set to [`KeyFileError::InvalidValue`][crate::KeyFileError::InvalidValue].
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    ///
    ///  the values associated with the key as a list of doubles, or [`None`] if the
    ///  key was not found or could not be parsed. The returned list of doubles
    ///  should be freed with `g_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 = mem::MaybeUninit::uninit();
            let mut error = 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 usize,
                ))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns all groups in the key file loaded with `self`.
    /// The array of returned groups will be [`None`]-terminated, so
    /// `length` may optionally be [`None`].
    ///
    /// # Returns
    ///
    /// a newly-allocated [`None`]-terminated array of strings.
    ///  Use `g_strfreev()` to free it.
    ///
    /// ## `length`
    /// return location for the number of returned groups, or [`None`]
    #[doc(alias = "g_key_file_get_groups")]
    #[doc(alias = "get_groups")]
    pub fn groups(&self) -> (Vec<crate::GString>, usize) {
        unsafe {
            let mut length = mem::MaybeUninit::uninit();
            let ret = FromGlibPtrContainer::from_glib_full(ffi::g_key_file_get_groups(
                self.to_glib_none().0,
                length.as_mut_ptr(),
            ));
            let length = length.assume_init();
            (ret, length)
        }
    }

    /// 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 non-[`None`] group name
    /// ## `key`
    /// a non-[`None`] 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 = 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 0 is returned and `error` is set to
    /// [`KeyFileError::KeyNotFound`][crate::KeyFileError::KeyNotFound]. Likewise, if the value associated
    /// with `key` cannot be interpreted as an integer, or is out of range
    /// for a `gint`, then 0 is returned
    /// and `error` is set to [`KeyFileError::InvalidValue`][crate::KeyFileError::InvalidValue].
    /// ## `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 = 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 [`None`] is returned and `error` is set to
    /// [`KeyFileError::KeyNotFound`][crate::KeyFileError::KeyNotFound]. Likewise, if the values associated
    /// with `key` cannot be interpreted as integers, or are out of range for
    /// `gint`, then [`None`] is returned
    /// and `error` is set to [`KeyFileError::InvalidValue`][crate::KeyFileError::InvalidValue].
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    ///
    ///  the values associated with the key as a list of integers, or [`None`] if
    ///  the key was not found or could not be parsed. The returned list of
    ///  integers should be freed with `g_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 = mem::MaybeUninit::uninit();
            let mut error = 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 usize,
                ))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Returns all keys for the group name `group_name`. The array of
    /// returned keys will be [`None`]-terminated, so `length` may
    /// optionally be [`None`]. In the event that the `group_name` cannot
    /// be found, [`None`] is returned and `error` is set to
    /// [`KeyFileError::GroupNotFound`][crate::KeyFileError::GroupNotFound].
    /// ## `group_name`
    /// a group name
    ///
    /// # Returns
    ///
    /// a newly-allocated [`None`]-terminated array of strings.
    ///  Use `g_strfreev()` to free it.
    ///
    /// ## `length`
    /// return location for the number of keys returned, or [`None`]
    #[doc(alias = "g_key_file_get_keys")]
    #[doc(alias = "get_keys")]
    pub fn keys(&self, group_name: &str) -> Result<(Vec<crate::GString>, usize), crate::Error> {
        unsafe {
            let mut length = mem::MaybeUninit::uninit();
            let mut error = ptr::null_mut();
            let ret = ffi::g_key_file_get_keys(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                length.as_mut_ptr(),
                &mut error,
            );
            let length = length.assume_init();
            if error.is_null() {
                Ok((FromGlibPtrContainer::from_glib_full(ret), length))
            } 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 [`None`]
    ///
    /// # Returns
    ///
    /// the locale from the file, or [`None`] if the key was not
    ///  found or the entry in the file was was untranslated
    #[cfg(any(feature = "v2_56", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_56")))]
    #[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 non-[`None`] group name
    /// ## `key`
    /// a non-[`None`] 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 = 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.
    ///
    /// In the event the key cannot be found, [`None`] is returned and
    /// `error` is set to [`KeyFileError::KeyNotFound`][crate::KeyFileError::KeyNotFound]. In the
    /// event that the `group_name` cannot be found, [`None`] is returned
    /// and `error` is set to [`KeyFileError::GroupNotFound`][crate::KeyFileError::GroupNotFound].
    /// ## `group_name`
    /// a group name
    /// ## `key`
    /// a key
    ///
    /// # Returns
    ///
    /// a newly allocated string or [`None`] 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 = 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 `error` is set to a [`KeyFileError`][crate::KeyFileError].
    /// ## `bytes`
    /// a [`Bytes`][crate::Bytes]
    /// ## `flags`
    /// flags from [`KeyFileFlags`][crate::KeyFileFlags]
    ///
    /// # Returns
    ///
    /// [`true`] if a key file could be loaded, [`false`] otherwise
    #[cfg(any(feature = "v2_50", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_50")))]
    #[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 = ptr::null_mut();
            let _ = ffi::g_key_file_load_from_bytes(
                self.to_glib_none().0,
                bytes.to_glib_none().0,
                flags.into_glib(),
                &mut error,
            );
            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 `error` is set to a [`KeyFileError`][crate::KeyFileError].
    /// ## `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 usize;
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_key_file_load_from_data(
                self.to_glib_none().0,
                data.to_glib_none().0,
                length,
                flags.into_glib(),
                &mut error,
            );
            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
    /// `G_FILE_ERROR` is returned. If there is a problem parsing the file, a
    /// `G_KEY_FILE_ERROR` is returned.
    ///
    /// This function will never return a [`KeyFileError::NotFound`][crate::KeyFileError::NotFound] error. If the
    /// `file` is not found, `G_FILE_ERROR_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<P: AsRef<std::path::Path>>(
        &self,
        file: P,
        flags: KeyFileFlags,
    ) -> Result<(), crate::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_key_file_load_from_file(
                self.to_glib_none().0,
                file.as_ref().to_glib_none().0,
                flags.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Removes a comment above `key` from `group_name`.
    /// If `key` is [`None`] then `comment` will be removed above `group_name`.
    /// If both `key` and `group_name` are [`None`], then `comment` will
    /// be removed above the first group in the file.
    /// ## `group_name`
    /// a group name, or [`None`]
    /// ## `key`
    /// a key
    ///
    /// # 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 = ptr::null_mut();
            let _ = ffi::g_key_file_remove_comment(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                &mut error,
            );
            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 = ptr::null_mut();
            let _ = ffi::g_key_file_remove_group(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                &mut error,
            );
            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 = ptr::null_mut();
            let _ = ffi::g_key_file_remove_key(
                self.to_glib_none().0,
                group_name.to_glib_none().0,
                key.to_glib_none().0,
                &mut error,
            );
            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 [`None`] then `comment` will be written above `group_name`.
    /// If both `key` and `group_name` are [`None`], then `comment` will be
    /// written above the first group in the file.
    ///
    /// Note that this function prepends a '#' comment marker to
    /// each line of `comment`.
    /// ## `group_name`
    /// a group name, or [`None`]
    /// ## `key`
    /// a key
    /// ## `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 = ptr::null_mut();
            let _ = 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,
            );
            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.
    /// ## `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()
    }
}