GLib Documentation

https://docs.rs/glib/latest/
Admin
This project provides comprehensive documentation for the GLib library, detailing its various...
Tokens:1,627,722
Snippets:13,069
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example: Get, Unset, and Set Flags

Source: https://docs.rs/glib/latest/glib/enums/struct.FlagsBuilder.html

This example demonstrates how to retrieve existing flags from an object, unset specific flags by their nick, and then set the modified flags back onto the object. It uses the FlagsBuilder to perform these operations.

```rust
let flags = obj.property("flags").unwrap();
let flags_class = FlagsClass::new(flags.type_()).unwrap();
let flags = flags_class.builder_with_value(flags).unwrap()
    .unset_by_nick("some-flag")
    .unset_by_nick("some-other-flag")
    .build()
    .unwrap();
obj.set_property("flags", &flags).unwrap();
```

--------------------------------

### Example Usage of SimpleObject

Source: https://docs.rs/glib/latest/glib/subclass/index.html

This snippet demonstrates how to create an instance of `SimpleObject` and interact with its properties. It shows setting and getting properties like 'name', 'animal', and 'flags' using the `ObjectExt` trait.

```rust
pub fn main() {
    let obj = SimpleObject::new();

    // Get the name property and change its value.
    // The `ObjectExt` trait provides implementations of
    // `glib::Object`'s public methods on the (wrappers of)
    // GObject subclasses. These invoke the corresponding GObject
    // virtual methods across the FFI interface, which in turn proxy
    // the `ObjectImpl` methods on the private instance struct above.
    assert_eq!(obj.property::<Option<String>>("name"), None);
    obj.set_property("name", "test");
    assert_eq!(&obj.property::<String>("name"), "test");

    assert_eq!(obj.property::<Animal>("animal"), Animal::Goat);
    obj.set_property("animal", Animal::Cat);
    assert_eq!(obj.property::<Animal>("animal"), Animal::Cat);

    assert_eq!(obj.property::<MyFlags>("flags"), MyFlags::A);
    obj.set_property("flags", MyFlags::B);
    assert_eq!(obj.property::<MyFlags>("flags"), MyFlags::B);
}

```

--------------------------------

### Get System Configuration Directories

Source: https://docs.rs/glib/latest/glib/fn.system_config_dirs.html

This snippet demonstrates how to call the `system_config_dirs` function to get a list of system configuration directories. It then iterates over the returned paths and prints them.

```rust
use glib::fn::system_config_dirs;

fn main() {
    let config_dirs = system_config_dirs();
    for dir in config_dirs {
        println!("{}", dir.display());
    }
}
```

--------------------------------

### Partial Sort Unstable By Key Example

Source: https://docs.rs/glib/latest/glib/collections/slice/struct.Slice.html

Demonstrates the `partial_sort_unstable_by_key` method for partial sorting based on a key extraction function. The examples cover various range specifications and show how the slice is partitioned and sorted according to the extracted keys.

```rust
#![feature(slice_partial_sort_unstable)]

let mut v = [4, -5, 1, -3, 2];

// empty range at the beginning, nothing changed
v.partial_sort_unstable_by_key(0..0, |x| *x);
assert_eq!(v, [4, -5, 1, -3, 2]);

// empty range in the middle, partitioning the slice
v.partial_sort_unstable_by_key(2..2, |x| *x);
for i in 0..2 {
   assert!(v[i] <= v[2]);
}
for i in 3..v.len() {
  assert!(v[2] <= v[i]);
}

// single element range, same as select_nth_unstable
v.partial_sort_unstable_by_key(2..3, |x| *x);
for i in 0..2 {
   assert!(v[i] <= v[2]);
}
for i in 3..v.len() {
  assert!(v[2] <= v[i]);
}

// partial sort a subrange
v.partial_sort_unstable_by_key(1..4, |x| *x);
assert_eq!(&v[1..4], [-3, 1, 2]);

// partial sort the whole range, same as sort_unstable
v.partial_sort_unstable_by_key(.., |x| *x);
assert_eq!(v, [-5, -3, 1, 2, 4]);

```

--------------------------------

### Get Length of Slice Example

Source: https://docs.rs/glib/latest/glib/collections/strv/struct.StrVRef.html

Demonstrates how to get the number of elements in a slice using the len() method.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Create a new BookmarkFile

Source: https://docs.rs/glib/latest/glib/struct.BookmarkFile.html

Initializes a new BookmarkFile instance. This is the starting point for managing bookmarks.

```rust
pub fn new() -> BookmarkFile
```

--------------------------------

### Build Simple Object with Properties

Source: https://docs.rs/glib/latest/src/glib/subclass/object.rs.html

Demonstrates building a `SimpleObject` with initial properties using the `Object::builder`.

```rust
let obj = Object::builder::<SimpleObject>()
    .property("construct-name", "meh")
    .property("name", "initial")
    .build();

assert_eq!(obj.property::<String>("construct-name"), String::from("meh"));

assert_eq!(obj.property::<String>("name"), String::from("initial"));
```

--------------------------------

### Get Last Element of Slice Example

Source: https://docs.rs/glib/latest/glib/collections/strv/struct.StrVRef.html

Demonstrates how to get the last element of a slice using the last() method, returning an Option.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Create a new KeyFile instance

Source: https://docs.rs/glib/latest/glib/struct.KeyFile.html

Instantiates a new, empty KeyFile object. This is the starting point for creating or manipulating configuration data.

```rust
pub fn new() -> KeyFile
```

--------------------------------

### Get First Element of Slice Example

Source: https://docs.rs/glib/latest/glib/collections/strv/struct.StrVRef.html

Demonstrates how to get the first element of a slice using the first() method, returning an Option.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

--------------------------------

### SIMD Slice Partitioning Example

Source: https://docs.rs/glib/latest/glib/struct.ByteArray.html

Demonstrates how to partition a slice into prefix, middle, and suffix parts using SIMD types. Useful for processing slices with SIMD instructions, especially when the slice length is not a multiple of the SIMD lane count.

```rust
#![feature(portable_simd)]
use core::simd::prelude::*;

let short = &[1, 2, 3];
let (prefix, middle, suffix) = short.as_simd::<4>();
assert_eq!(middle, []); // Not enough elements for anything in the middle

// They might be split in any possible way between prefix and suffix
let it = prefix.iter().chain(suffix).copied();
assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);

fn basic_simd_sum(x: &[f32]) -> f32 {
    use std::ops::Add;
    let (prefix, middle, suffix) = x.as_simd();
    let sums = f32x4::from_array([
        prefix.iter().copied().sum(),
        0.0,
        0.0,
        suffix.iter().copied().sum(),
    ]);
    let sums = middle.iter().copied().fold(sums, f32x4::add);
    sums.reduce_sum()
}

let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);

```

--------------------------------

### Get Tag Start Position

Source: https://docs.rs/glib/latest/glib/struct.MarkupParseContext.html

Retrieves the position (line, column, byte offset) where the current tag started. Available on 'v2_88' feature.

```rust
pub fn tag_start(&self) -> (usize, usize, usize)>
```

--------------------------------

### Fetching match position

Source: https://docs.rs/glib/latest/src/glib/match_info.rs.html

Uses `g_match_info_fetch_pos` to get the start and end positions of a specific match.

```rust
pub fn fetch_pos(&self, match_num: i32) -> Option<(i32, i32)> {
    unsafe {
        let mut start_pos = std::mem::MaybeUninit::uninit();
        let mut end_pos = std::mem::MaybeUninit::uninit();
        let ret = from_glib(ffi::g_match_info_fetch_pos(
            self.to_glib_none().0,
            match_num,
            start_pos.as_mut_ptr(),
            end_pos.as_mut_ptr(),
        ));
        if ret {

```

--------------------------------

### Create, Populate, and Convert to Variant

Source: https://docs.rs/glib/latest/src/glib/variant_dict.rs.html

Demonstrates creating a VariantDict, populating it, and converting it into a Variant.

```rust
let dict = VariantDict::default();
dict.insert_value("one", &(1u8.to_variant()));
let var: Variant = dict.to_variant();
let dict = VariantDict::from_variant(&var).expect("Not a dict?");
assert_eq!(dict.lookup_value("one", None), Some(1u8.to_variant()));
```

--------------------------------

### Using a GLib Object with Properties

Source: https://docs.rs/glib/latest/glib/derive.Properties.html

This example demonstrates how to instantiate and use a GLib object that has properties defined using the `Properties` derive macro. It shows setting a property with a custom setter and then retrieving its value.

```rust
fn main() {
  let myfoo: Foo = glib::object::Object::new();

  myfoo.set_fizz("test value");
  assert_eq!(myfoo.fizz(), "custom set: test value".to_string());
}
```

--------------------------------

### Get Sunday Weeks in Year

Source: https://docs.rs/glib/latest/glib/struct.Date.html

Calculates the number of weeks in a year, where weeks start on Sunday.

```rust
pub fn sunday_weeks_in_year(year: DateYear) -> u8
```

--------------------------------

### Get Monday Weeks in Year

Source: https://docs.rs/glib/latest/glib/struct.Date.html

Calculates the number of weeks in a year, where weeks start on Monday.

```rust
pub fn monday_weeks_in_year(year: DateYear) -> u8
```

--------------------------------

### BookmarkFile::new

Source: https://docs.rs/glib/latest/glib/struct.BookmarkFile.html

Creates a new, empty BookmarkFile. This is the starting point for managing bookmarks.

```APIDOC
## BookmarkFile::new

### Description
Creates a new, empty BookmarkFile.

### Method
`BookmarkFile::new()`

### Returns
A new `BookmarkFile` instance.
```

--------------------------------

### Get Sunday Week of the Year

Source: https://docs.rs/glib/latest/glib/struct.Date.html

Retrieves the week number of the year, where the week starts on Sunday.

```rust
pub fn sunday_week_of_year(&self) -> u32
```

--------------------------------

### Creating a temporary directory with mkdtemp_full

Source: https://docs.rs/glib/latest/glib/fn.mkdtemp_full.html

This snippet demonstrates how to use `mkdtemp_full` to create a temporary directory. Ensure the `glib` crate is added as a dependency.

```rust
use glib::Path;
use std::path::PathBuf;

fn main() {
    let tmpl = "/tmp/my-temp-dir.XXXXXX";
    let mode = 0o700;

    match glib::mkdtemp_full(tmpl, mode) {
        Some(path) => {
            println!("Created temporary directory: {:?}", path);
            // You can now use the directory, e.g., create files inside it.
            // Remember to clean it up when done, though mkdtemp_full itself doesn't auto-remove.
            // std::fs::remove_dir_all(path).expect("Failed to remove temp dir");
        }
        None => {
            eprintln!("Failed to create temporary directory.");
        }
    }
}
```

--------------------------------

### Get Monday Week of the Year

Source: https://docs.rs/glib/latest/glib/struct.Date.html

Retrieves the week number of the year, where the week starts on Monday.

```rust
pub fn monday_week_of_year(&self) -> u32
```

--------------------------------

### GlibLogger Initialization

Source: https://docs.rs/glib/latest/src/glib/bridged_logging.rs.html

Shows how to create a new GlibLogger instance with specified formatting and domain handling behaviors. This logger routes 'log' crate messages to GLib.

```rust
pub const fn new(format: GlibLoggerFormat, domain: GlibLoggerDomain) -> Self {
    Self { format, domain }
}

```

--------------------------------

### MainContext::new

Source: https://docs.rs/glib/latest/glib/struct.MainContext.html

Creates a new MainContext. This is the default way to create a new main loop context.

```APIDOC
## MainContext::new

### Description
Creates a new MainContext.

### Method
`new()`

### Returns
A new `MainContext` instance.
```

--------------------------------

### TypeData::impl_offset() - Get Implementation Offset

Source: https://docs.rs/glib/latest/glib/subclass/types/struct.TypeData.html

Returns the offset in bytes of the private implementation struct relative to the start of the instance struct.

```rust
pub fn impl_offset(&self) -> isize
```

--------------------------------

### Bytes Creation and Usage

Source: https://docs.rs/glib/latest/glib/struct.Bytes.html

Demonstrates how to create Bytes instances from vectors and static byte slices, showcasing the efficiency of Bytes.

```APIDOC
## Bytes

A shared immutable byte slice (the equivalent of `Rc<[u8]>`).
`From` implementations that take references (e.g. `&[u8]`) copy the data. The `from_static` constructor avoids copying static data.

```rust
use glib::Bytes;

let v = vec![1, 2, 3];
let b = Bytes::from(&v);
assert_eq!(v, b);

let s = b"xyz";
let b = Bytes::from_static(s);
assert_eq!(&s[..], b);
```
```

--------------------------------

### Property Getter Examples

Source: https://docs.rs/glib/latest/glib/derive.Properties.html

Specify that a property is readable using the `get` attribute. You can use the default `PropertyGet::get` implementation or provide a custom getter function.

```rust
#[property(get)]
```

```rust
#[property(get = get_prop)]
```

```rust
#[property(get = |_| 2)]
```

--------------------------------

### Load BookmarkFile from Data Directories

Source: https://docs.rs/glib/latest/src/glib/bookmark_file.rs.html

Loads bookmark data from a file specified by a path, resolving it through data directories. Returns the full path of the loaded file or an error.

```rust
pub fn load_from_data_dirs(
    &mut self,
    file: impl AsRef<std::path::Path>,
) -> Result<std::path::PathBuf, crate::Error> {
    unsafe {
        let mut full_path = std::ptr::null_mut();
        let mut error = std::ptr::null_mut();
        let is_ok = ffi::g_bookmark_file_load_from_data_dirs(
            self.to_glib_none_mut().0,
            file.as_ref().to_glib_none().0,
            &mut full_path,
            &mut error,
        );
        debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
        if error.is_null() {
            Ok(from_glib_full(full_path))
        } else {
            Err(from_glib_full(error))
        }
    }
}
```

--------------------------------

### Mutably iterating over reverse chunks of a slice

Source: https://docs.rs/glib/latest/glib/collections/ptr_slice/struct.PtrSlice.html

Shows how to use `rchunks_mut` to get mutable references to chunks of a slice, starting from the end. The last chunk can be smaller.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);
```

--------------------------------

### Using SIMD with Slice Alignment

Source: https://docs.rs/glib/latest/glib/collections/strv/struct.StrVRef.html

Demonstrates splitting a slice into prefix, middle (SIMD types), and suffix using `as_simd`. Includes an example of summing elements using SIMD operations and handling potential panics related to SIMD lane configuration.

```rust
#![feature(portable_simd)]
use core::simd::prelude::*;

let short = &[1, 2, 3];
let (prefix, middle, suffix) = short.as_simd::<4>();
assert_eq!(middle, []); // Not enough elements for anything in the middle

// They might be split in any possible way between prefix and suffix
let it = prefix.iter().chain(suffix).copied();
assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);

fn basic_simd_sum(x: &[f32]) -> f32 {
    use std::ops::Add;
    let (prefix, middle, suffix) = x.as_simd();
    let sums = f32x4::from_array([
        prefix.iter().copied().sum(),
        0.0,
        0.0,
        suffix.iter().copied().sum(),
    ]);
    let sums = middle.iter().copied().fold(sums, f32x4::add);
    sums.reduce_sum()
}

let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);
```

--------------------------------

### Convert and Get Char

Source: https://docs.rs/glib/latest/src/glib/value.rs.html

Shows conversion of a Rust char to a GLib Value and retrieval. Includes an example of attempting to retrieve an invalid char value, resulting in an error.

```rust
let c_v = 'c'.to_value();
assert_eq!(c_v.get::<char>(), Ok('c'));

let c_v = 0xFFFFFFFFu32.to_value();
assert_eq!(
    c_v.get::<char>(),
    Err(InvalidCharError::CharConversionError)
);
```

--------------------------------

### Get Last Chunk of Slice Example

Source: https://docs.rs/glib/latest/glib/collections/strv/struct.StrVRef.html

Demonstrates retrieving the last N elements of a slice as an array reference using last_chunk(). Returns None if the slice is too short.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

--------------------------------

### BoxedAnyObject Example

Source: https://docs.rs/glib/latest/src/glib/object.rs.html

Demonstrates creating, cloning, inserting, and retrieving a BoxedAnyObject from a collection.

```rust
let mut m = std::collections::HashMap::new();
        let boxed_object = crate::BoxedAnyObject::new("");

        m.insert(boxed_object.clone());

        let object: &Object = std::borrow::Borrow::borrow(&boxed_object);
        assert_eq!(m.get(object), Some(&boxed_object));
```

--------------------------------

### Using glib::info! Macro

Source: https://docs.rs/glib/latest/glib/macro.info.html

Example of how to use the glib::info! macro to log a message under a specific domain. Ensure the 'log_macros' feature is enabled and GlibLogger is initialized.

```rust
static G_LOG_DOMAIN: &str = "my-domain";

glib::info!("This will be logged under 'my-domain'");
```

--------------------------------

### Get First Chunk of Slice Example

Source: https://docs.rs/glib/latest/glib/collections/strv/struct.StrVRef.html

Demonstrates retrieving the first N elements of a slice as an array reference using first_chunk(). Returns None if the slice is too short.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

--------------------------------

### Using glib::debug! with G_LOG_DOMAIN

Source: https://docs.rs/glib/latest/glib/macro.debug.html

Example of using the glib::debug! macro. Ensure the 'log_macros' feature is enabled and GlibLogger is initialized with GlibLoggerDomain::CrateTarget.

```rust
static G_LOG_DOMAIN: &str = "my-domain";

glib::debug!("This will be logged under 'my-domain'");
```

--------------------------------

### Get Enclosing Function Name

Source: https://docs.rs/glib/latest/glib/macro.function_name.html

This example demonstrates how to use the glib::function_name macro within a function to assert its name. The macro derives its functionality from std::any::type_name.

```rust
mod bar {
    pub fn sample_function() {
        assert!(glib::function_name!().ends_with("bar::sample_function"));
    }
}

bar::sample_function();
```

--------------------------------

### Creating and Inspecting GLib Values

Source: https://docs.rs/glib/latest/src/glib/value.rs.html

Demonstrates how to create `Value` instances from various Rust types using `to_value()` and `Value::from()`. It also shows how to check the type of a `Value` using `is()` and retrieve its content with `get()`, handling potential type mismatches.

```rust
use glib::prelude::*;
use glib::Value;

// Value implement From<&i32>, From<&str> and From<Option<&str>>.
// Another option is the `ToValue` trait.
let mut num = 10.to_value();
let mut hello = Value::from("Hello!");
let none: Option<&str> = None;
let str_none = none.to_value();

// `is` tests the type of the value.
assert!(num.is::<i32>());
assert!(hello.is::<String>());

// `get` tries to get an optional value of the specified type
// and returns an `Err` if the type doesn't match.
assert_eq!(num.get(), Ok(10));
assert!(num.get::<String>().is_err());
assert_eq!(hello.get(), Ok(String::from("Hello!")));
assert_eq!(hello.get::<String>(), Ok(String::from("Hello!")));
assert_eq!(str_none.get::<Option<String>>(), Ok(None));

```

--------------------------------

### Create and Append to SList (from_glib_full)

Source: https://docs.rs/glib/latest/src/glib/collections/slist.rs.html

Demonstrates creating a new SList and appending items using `to_glib_full`. This method takes ownership of the appended items.

```rust
let list = unsafe {
            let mut list = ffi::g_slist_append(
                ptr::null_mut(),
                ToGlibPtr::<*mut ffi::GDateTime>::to_glib_full(&items[0]) as ffi::gpointer,
            );
            list = ffi::g_slist_append(
                list,
                ToGlibPtr::<*mut ffi::GDateTime>::to_glib_full(&items[1]) as ffi::gpointer,
            );
            list = ffi::g_slist_append(
                list,
                ToGlibPtr::<*mut ffi::GDateTime>::to_glib_full(&items[2]) as ffi::gpointer,
            );
            list = ffi::g_slist_append(
                list,
                ToGlibPtr::<*mut ffi::GDateTime>::to_glib_full(&items[3]) as ffi::gpointer,
            );
            SList::<crate::DateTime>::from_glib_full(list)
        };
        assert!(!list.is_empty());

        let list_items = list.iter().cloned().collect::<Vec<_>>();
        assert_eq!(&items[..], &list_items);

        let list_items = list.iter_mut().map(|d| d.clone()).collect::<Vec<_>>();
        assert_eq!(&items[..], &list_items);

        let list_items = list.into_iter().collect::<Vec<_>>();
        assert_eq!(&items[..], &list_items);

        let list = unsafe { SList::<crate::DateTime>::from_glib_full(ptr::null_mut()) };
        assert!(list.is_empty());
```

--------------------------------

### Get the codeset name

Source: https://docs.rs/glib/latest/glib/fn.codeset.html

This snippet shows how to call the `codeset` function to retrieve the codeset name of the current locale. No specific setup or imports are required beyond having the glib crate available.

```rust
use glib::codeset;

fn main() {
    let codeset_name = codeset();
    println!("Current codeset: {}", codeset_name);
}
```

--------------------------------

### List Manipulation and Iteration Example

Source: https://docs.rs/glib/latest/src/glib/collections/list.rs.html

Demonstrates creating a list from a slice, adding elements to the front and back, iterating, and reversing the list. Also shows cloning and retaining elements based on a condition.

```rust
let mut list = items[1..3].iter().cloned().collect::<List<_>>();
assert_eq!(list.len(), 2);
list.push_front(items[0].clone());
assert_eq!(list.len(), 3);
list.push_back(items[3].clone());
assert_eq!(list.len(), 4);

let list_items = list.iter().cloned().collect::<Vec<_>>();
assert_eq!(&items[..], &list_items);

assert_eq!(list.front(), Some(&items[0]));
assert_eq!(list.back(), Some(&items[3]));
assert_eq!(list.pop_front().as_ref(), Some(&items[0]));
assert_eq!(list.len(), 3);

list.reverse();
let mut list_items = list.iter().cloned().collect::<Vec<_>>();
list_items.reverse();
assert_eq!(&items[1..], &list_items);

let list2 = list.clone();
let mut list_items = list2.iter().cloned().collect::<Vec<_>>();
list_items.reverse();
assert_eq!(&items[1..], &list_items);

list.reverse();
let mut list3 = list.clone();
list3.retain(|item| item.seconds() >= 14.0);
let list_items = list3.iter().cloned().collect::<Vec<_>>();
assert_eq!(&items[2..], &list_items);
```

--------------------------------

### Get Locale Character Set Information

Source: https://docs.rs/glib/latest/glib/fn.charset.html

Use this function to determine if the current locale's encoding is UTF-8 and to retrieve the charset name if available. No setup or imports are required beyond having the glib crate available.

```rust
pub fn charset() -> (bool, Option<&'static GStr>)
```

--------------------------------

### spawn_async

Source: https://docs.rs/glib/latest/glib/fn.spawn_async.html

Spawns a child process asynchronously. This function is non-blocking and returns a `Pid` immediately. The `child_setup` closure is executed in the child process before the new program is executed.

```APIDOC
## spawn_async

### Description
Spawns a child process asynchronously. This function is non-blocking and returns a `Pid` immediately. The `child_setup` closure is executed in the child process before the new program is executed.

### Function Signature
```rust
pub fn spawn_async(
    working_directory: Option<impl AsRef<Path>>,
    argv: &[&Path],
    envp: &[&Path],
    flags: SpawnFlags,
    child_setup: Option<Box<dyn FnOnce() + 'static>>,
) -> Result<Pid, Error>
```

### Parameters
* `working_directory`: An optional path to the working directory for the child process.
* `argv`: A slice of paths representing the arguments for the new program. The first element is typically the program name.
* `envp`: A slice of paths representing the environment variables for the child process.
* `flags`: A `SpawnFlags` value that controls the behavior of the spawned process.
* `child_setup`: An optional closure that will be executed in the child process before the new program is executed. It must be `Send` and `'static`.

### Returns
A `Result` containing the `Pid` of the spawned process on success, or an `Error` on failure.
```

--------------------------------

### Iterating Slice Chunks from the End

Source: https://docs.rs/glib/latest/glib/collections/strv/struct.StrV.html

Use `rchunks` to get an iterator over slice elements in chunks of a specified size, starting from the end. The last chunk may be smaller if the slice length is not divisible by `chunk_size`. Panics if `chunk_size` is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());
```

--------------------------------

### Iterating Exact Slice Chunks from the End

Source: https://docs.rs/glib/latest/glib/collections/strv/struct.StrV.html

Use `rchunks_exact` to get an iterator over slice elements in chunks of exactly `chunk_size`, starting from the end. Any remaining elements that do not form a full chunk can be retrieved using the `remainder` method. Panics if `chunk_size` is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['l']);
```

--------------------------------

### UChar Creation and Conversion Examples

Source: https://docs.rs/glib/latest/glib/char/struct.UChar.html

Demonstrates creating UChar instances from bytes and characters, and attempting conversion from a character that exceeds the unsigned char range.

```rust
use glib::UChar;
use std::convert::TryFrom;

UChar::from(b'a');
UChar::try_from('a').unwrap();
assert!(UChar::try_from('☔').is_err());
```

--------------------------------

### unset_print_handler

Source: https://docs.rs/glib/latest/glib/fn.unset_print_handler.html

Removes the currently installed print handler. If no handler is installed, this function has no effect.

```APIDOC
## unset_print_handler

### Description
Removes the currently installed print handler. If no handler is installed, this function has no effect.

### Method
`fn unset_print_handler()`

### Parameters
This function takes no parameters.

### Returns
This function does not return a value.
```

--------------------------------

### Create and Populate VariantDict

Source: https://docs.rs/glib/latest/src/glib/variant_dict.rs.html

Shows how to create a new VariantDict and insert a key-value pair.

```rust
let dict = VariantDict::default();
dict.insert_value("one", &(1u8.to_variant()));
assert_eq!(dict.lookup_value("one", None), Some(1u8.to_variant()));
```

--------------------------------

### Get Type ID from Any Trait

Source: https://docs.rs/glib/latest/glib/object/struct.Interface.html

Gets the TypeId of the implementing type. This is a blanket implementation for any type T.

```rust
fn type_id(&self) -> TypeId

```

--------------------------------

### Creating a Glib Dictionary with DictEntry

Source: https://docs.rs/glib/latest/glib/variant/struct.DictEntry.html

This snippet demonstrates how to create a dictionary using `DictEntry::new` and collect it into a `glib::variant::Variant`. Ensure you have the necessary imports for `Variant`, `FromVariant`, and `DictEntry`.

```rust
use glib::variant::{Variant, FromVariant, DictEntry};

let entries = [
    DictEntry::new("uuid", 1000u32),
    DictEntry::new("guid", 1001u32),
];
let dict = entries.into_iter().collect::<Variant>();
assert_eq!(dict.n_children(), 2);
assert_eq!(dict.type_().as_str(), "a{su}");
```

--------------------------------

### Get Number of Processors

Source: https://docs.rs/glib/latest/glib/fn.num_processors.html

This snippet shows how to get the number of available processors using the `num_processors` function.

```rust
use glib::num_processors;

fn main() {
    let num = num_processors();
    println!("Number of processors: {}", num);
}
```

--------------------------------

### KeyFile::new

Source: https://docs.rs/glib/latest/src/glib/auto/key_file.rs.html

Creates a new, empty GKeyFile object. This is the starting point for creating or manipulating key file data.

```APIDOC
## KeyFile::new

### Description
Creates a new, empty GKeyFile object. This is the starting point for creating or manipulating key file data.

### Method

```rust
pub fn new() -> KeyFile
```

### Returns
A new `KeyFile` instance.
```

--------------------------------

### Get Program Name (Internal)

Source: https://docs.rs/glib/latest/src/glib/utils.rs.html

Gets the program's name using `g_get_prgname()`. Returns `None` if the name is not set.

```rust
pub fn prgname() -> Option<GString> {
    unsafe { from_glib_none(ffi::g_get_prgname()) }
}
```

--------------------------------

### Get the title of a bookmark

Source: https://docs.rs/glib/latest/glib/struct.BookmarkFile.html

Retrieves the title associated with a bookmark URI. If no URI is provided, it attempts to get a default title.

```rust
pub fn title(&self, uri: Option<&str>) -> Result<GString, Error>
```

--------------------------------

### Initialize and Use GlibLogger with Log Crate

Source: https://docs.rs/glib/latest/glib/struct.GlibLogger.html

This snippet demonstrates how to create a GlibLogger instance, set it as the global logger for the log crate, and then log a message. Ensure the 'log' feature is enabled for glib.

```rust
static glib_logger: glib::GlibLogger = glib::GlibLogger::new(
    glib::GlibLoggerFormat::Plain,
    glib::GlibLoggerDomain::CrateTarget,
);

log::set_logger(&glib_logger);
log::set_max_level(log::LevelFilter::Debug);

log::info!("This line will get logged by glib");
```

--------------------------------

### Get Interface from Type

Source: https://docs.rs/glib/latest/glib/object/struct.Interface.html

Safely gets the default interface struct for Self from a Type. Returns None if the type is not an interface.

```rust
pub fn from_type(type_: Type) -> Option<InterfaceRef<'static, T>>

```

--------------------------------

### Working with GLib Values

Source: https://docs.rs/glib/latest/glib/value/index.html

Demonstrates creating, checking types, and retrieving values from `glib::Value`. Supports conversion from primitives and strings using `to_value()` or `Value::from()`. Use `is::<T>()` to check the type and `get::<T>()` to retrieve the value.

```rust
use glib::prelude::*; // or `use gtk::prelude::*;`
use glib::Value;

// Value implement From<&i32>, From<&str> and From<Option<&str>>.
// Another option is the `ToValue` trait.
let mut num = 10.to_value();
let mut hello = Value::from("Hello!");
let none: Option<&str> = None;
let str_none = none.to_value();

// `is` tests the type of the value.
assert!(num.is::<i32>());
assert!(hello.is::<String>());

// `get` tries to get an optional value of the specified type
// and returns an `Err` if the type doesn't match.
assert_eq!(num.get(), Ok(10));
assert!(num.get::<String>().is_err());
assert_eq!(hello.get(), Ok(String::from("Hello!")));
assert_eq!(hello.get::<String>(), Ok(String::from("Hello!")));
assert_eq!(str_none.get::<Option<String>>(), Ok(None));
```

--------------------------------

### Get Interface from Class

Source: https://docs.rs/glib/latest/glib/object/struct.Interface.html

Safely gets the interface struct for Self from a given Class. Returns None if the class does not implement Self.

```rust
pub fn from_class<U: IsClass>(klass: &Class<U>) -> Option<InterfaceRef<'_, T>>

```

--------------------------------

### FileSetContentsFlags Initialization Methods

Source: https://docs.rs/glib/latest/glib/struct.FileSetContentsFlags.html

Provides methods for creating FileSetContentsFlags instances, including empty, all-bits-set, and from-bits conversions.

```rust
pub const fn empty() -> Self
```

```rust
pub const fn all() -> Self
```

```rust
pub const fn from_bits(bits: u32) -> Option<Self>
```

```rust
pub const fn from_bits_truncate(bits: u32) -> Self
```

```rust
pub const fn from_bits_retain(bits: u32) -> Self
```

--------------------------------

### Flags Builder Example

Source: https://docs.rs/glib/latest/src/glib/enums.rs.html

Illustrates how to use a `FlagsClass` builder to modify flags on an object property. This example is illustrative and marked as `ignore`.

```rust
```ignore
let flags = obj.property("flags").unwrap();
let flags_class = FlagsClass::new(flags.type_()).unwrap();
let flags = flags_class.builder_with_value(flags).unwrap()
    .unset_by_nick("some-flag")
    .unset_by_nick("some-other-flag")
    .build()
    .unwrap();
```
```

--------------------------------

### KeyFile Methods

Source: https://docs.rs/glib/latest/glib/struct.KeyFile.html

This section details the various methods available for interacting with KeyFile objects, including creating new KeyFiles, loading data from different sources, saving KeyFiles, and retrieving or setting various data types.

```APIDOC
## KeyFile

### Description
Represents a configuration file parser that allows for managing key-value pairs within groups.

### Methods

#### `new()`
Creates a new, empty `KeyFile` object.

#### `comment(group_name: Option<&str>, key: Option<&str>) -> Result<GString, Error>`
Retrieves the comment associated with a specific key or group.

#### `double(group_name: &str, key: &str) -> Result<f64, Error>`
Retrieves a double-precision floating-point value for a given key in a group.

#### `double_list(group_name: &str, key: &str) -> Result<Vec<f64>, Error>`
Retrieves a list of double-precision floating-point values for a given key in a group.

#### `int64(group_name: &str, key: &str) -> Result<i64, Error>`
Retrieves a 64-bit signed integer value for a given key in a group.

#### `integer(group_name: &str, key: &str) -> Result<i32, Error>`
Retrieves a 32-bit signed integer value for a given key in a group.

#### `integer_list(group_name: &str, key: &str) -> Result<Vec<i32>, Error>`
Retrieves a list of 32-bit signed integer values for a given key in a group.

#### `locale_for_key(group_name: &str, key: &str, locale: Option<&str>) -> Option<GString>`
Retrieves a locale-specific string value for a given key in a group.

#### `start_group() -> Option<GString>`
Retrieves the name of the first group in the KeyFile.

#### `uint64(group_name: &str, key: &str) -> Result<u64, Error>`
Retrieves a 64-bit unsigned integer value for a given key in a group.

#### `value(group_name: &str, key: &str) -> Result<GString, Error>`
Retrieves a string value for a given key in a group.

#### `has_group(group_name: &str) -> bool`
Checks if a group with the given name exists.

#### `load_from_bytes(bytes: &Bytes, flags: KeyFileFlags) -> Result<(), Error>`
Loads KeyFile data from a byte slice.

#### `load_from_data(data: &str, flags: KeyFileFlags) -> Result<(), Error>`
Loads KeyFile data from a string.

#### `load_from_file(file: impl AsRef<Path>, flags: KeyFileFlags) -> Result<(), Error>`
Loads KeyFile data from a file.

#### `remove_comment(group_name: Option<&str>, key: Option<&str>) -> Result<(), Error>`
Removes the comment associated with a specific key or group.

#### `remove_group(group_name: &str) -> Result<(), Error>`
Removes a group and all its keys from the KeyFile.

#### `remove_key(group_name: &str, key: &str) -> Result<(), Error>`
Removes a key and its associated value from a group.

#### `set_boolean(group_name: &str, key: &str, value: bool)`
Sets a boolean value for a given key in a group.

#### `set_comment(group_name: Option<&str>, key: Option<&str>, comment: &str) -> Result<(), Error>`
Sets a comment for a specific key or group.

#### `set_double(group_name: &str, key: &str, value: f64)`
Sets a double-precision floating-point value for a given key in a group.

#### `set_int64(group_name: &str, key: &str, value: i64)`
Sets a 64-bit signed integer value for a given key in a group.

#### `set_integer(group_name: &str, key: &str, value: i32)`
Sets a 32-bit signed integer value for a given key in a group.

#### `set_list_separator(separator: Char)`
Sets the list separator character.

#### `set_locale_string(group_name: &str, key: &str, locale: &str, string: &str)`
Sets a locale-specific string value for a given key in a group.

#### `set_string(group_name: &str, key: &str, string: &str)`
Sets a string value for a given key in a group.

#### `set_uint64(group_name: &str, key: &str, value: u64)`
Sets a 64-bit unsigned integer value for a given key in a group.

#### `set_value(group_name: &str, key: &str, value: &str)`
Sets a generic string value for a given key in a group.

#### `save_to_file<T: AsRef<Path>>(filename: T) -> Result<(), Error>`
Saves the KeyFile content to a file.

#### `load_from_data_dirs<T: AsRef<Path>>(file: T, flags: KeyFileFlags) -> Result<PathBuf, Error>`
Loads a KeyFile from a file, searching in standard directories.

#### `load_from_dirs<T: AsRef<Path>, U: AsRef<Path>>(file: T, search_dirs: &[U], flags: KeyFileFlags) -> Result<PathBuf, Error>`
Loads a KeyFile from a file, searching in specified directories.

#### `to_data() -> GString`
Serializes the KeyFile content to a string.

#### `groups() -> PtrSlice<GStringPtr>`
Retrieves a list of all group names in the KeyFile.

#### `keys(group_name: &str) -> Result<PtrSlice<GStringPtr>, Error>`
Retrieves a list of all key names within a specified group.

#### `boolean(group_name: &str, key: &str) -> Result<bool, Error>`
Retrieves a boolean value for a given key in a group.

#### `has_key(group_name: &str, key: &str) -> Result<bool, Error>`
Checks if a key exists within a specified group.

#### `boolean_list(group_name: &str, key: &str) -> Result<Vec<bool>, Error>`
Retrieves a list of boolean values for a given key in a group.

#### `string(group_name: &str, key: &str) -> Result<GString, Error>`
Retrieves a string value for a given key in a group.

#### `string_list(group_name: &str, key: &str) -> Result<PtrSlice<GStringPtr>, Error>`
Retrieves a list of string values for a given key in a group.

#### `locale_string(group_name: &str, key: &str, locale: Option<&str>) -> Result<GString, Error>`
Retrieves a locale-specific string value for a given key in a group.

#### `locale_string_list(group_name: &str, key: &str, locale: Option<&str>) -> Result<PtrSlice<GStringPtr>, Error>`
Retrieves a list of locale-specific string values for a given key in a group.

#### `as_ptr() -> *mut GKeyFile`
Returns a raw pointer to the underlying C `GKeyFile` structure.

#### `from_glib_ptr_borrow(ptr: &*mut GKeyFile) -> &Self`
Creates a borrowed reference to a `KeyFile` from a raw pointer to a `GKeyFile`.

### Trait Implementations

#### `Clone`

##### `clone() -> Self`
Creates a clone of the `KeyFile` instance, increasing the reference count.

##### `clone_from(&mut self, source: &Self)`
Performs copy-assignment from a source `KeyFile`.

#### `Debug`

##### `fmt(&self, f: &mut Formatter<'_>) -> Result`
Formats the `KeyFile` for debugging output.

#### `Default`

##### `default() -> Self`
Returns the default `KeyFile` instance.
```

--------------------------------

### Get and TryGet Variant Values

Source: https://docs.rs/glib/latest/src/glib/variant.rs.html

Shows how to retrieve values from a Variant using `get` and `try_get`, including error handling for type mismatches.

```rust
let u = 42u32.to_variant();
assert!(u.get::<i32>().is_none());
assert_eq!(u.get::<u32>().unwrap(), 42);
assert!(u.try_get::<i32>().is_err());
// Test ? conversion
assert_eq!(u.try_get::<u32>()?, 42);
```

--------------------------------

### Convert and Get Option<&String>

Source: https://docs.rs/glib/latest/src/glib/value.rs.html

Demonstrates converting an Option<&String> to a GLib Value and retrieving it. Covers cases with Some and None, and includes error handling for type mismatches.

```rust
let some_v = Some(&String::from("test")).to_value();
assert_eq!(some_v.get::<String>(), Ok(String::from("test")));
assert_eq!(
    some_v.get::<Option<String>>(),
    Ok(Some(String::from("test")))
);
assert_eq!(
    some_v.get::<i32>(),
    Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
);

let none_str: Option<&String> = None;
let none_v = none_str.to_value();
assert_eq!(none_v.get::<Option<String>>(), Ok(None));
assert_eq!(
    none_v.get::<i32>(),
    Err(ValueTypeMismatchError::new(Type::STRING, Type::I32))
);
```

--------------------------------

### Get Disjoint Mutable Slices

Source: https://docs.rs/glib/latest/glib/struct.ValueArray.html

Demonstrates how to get disjoint mutable slices from a mutable slice using `get_disjoint_mut` with different index patterns.

```rust
let v = &mut [1, 2, 3];
if let Ok([a, b]) = v.get_disjoint_mut([0, 2]) {
    *a = 413;
    *b = 612;
}
assert_eq!(v, &[413, 2, 612]);

if let Ok([a, b]) = v.get_disjoint_mut([0..1, 1..3]) {
    a[0] = 8;
    b[0] = 88;
    b[1] = 888;
}
assert_eq!(v, &[8, 88, 888]);

if let Ok([a, b]) = v.get_disjoint_mut([1..=2, 0..=0]) {
    a[0] = 11;
    a[1] = 111;
    b[0] = 1;
}
assert_eq!(v, &[1, 11, 111]);
```

--------------------------------

### Get Locale-Specific String

Source: https://docs.rs/glib/latest/glib/struct.KeyFile.html

Retrieves a string value for a key, considering a specific locale. If no locale is provided, it attempts to get the default string.

```rust
pub fn locale_string(&self, group_name: &str, key: &str, locale: Option<&str>) -> Result<GString, Error>
```

--------------------------------

### BookmarkFile::application_info

Source: https://docs.rs/glib/latest/glib/struct.BookmarkFile.html

Retrieves detailed application information for a bookmark. Available only with the `v2_66` feature flag.

```APIDOC
## BookmarkFile::application_info

### Description
Retrieves detailed application information for a bookmark. Available on `crate feature v2_66` only.

### Method
`BookmarkFile::application_info(&self, uri: &str, name: &str) -> Result<(GString, u32, DateTime), Error>`

### Parameters
* `uri` (str) - The URI of the bookmark.
* `name` (str) - The name of the application.

### Returns
A `Result` containing a tuple of `(GString, u32, DateTime)` representing the application's executable, count, and timestamp, or an `Error`.
```
Tokens:
Raw