### Example: Usage of device_name_from_tag

Source: https://docs.rs/rsblkid/latest/src/rsblkid/cache/cache_struct.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example setup for using the cache to find a device by UUID.

```rust
    let mut cache = Cache::builder()
        .discard_changes_on_drop()
        .build()?;

    cache.probe_all_devices()?;

    let uuid: Tag = r#"UUID="ac4f36bf-191b-4fb0-b808-6d7fc9fc88be""#.parse()?;
```

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

### Find device name with tag example

Source: https://docs.rs/rsblkid/latest/src/rsblkid/cache/cache_struct.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows the initial setup for finding a device name by tag, noting that only LABEL and UUID tags are supported.

```rust
# use pretty_assertions::assert_eq;
use std::path::PathBuf;
use rsblkid::device::Tag;
use rsblkid::cache::Cache;

fn main() -> rsblkid::Result<()> {
    let mut cache = Cache::builder()
        .discard_changes_on_drop()
        .build()?;

    cache.probe_all_devices()?;
```

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

### Print device properties and partition table entries with find_all_device_properties

Source: https://docs.rs/rsblkid/latest/src/rsblkid/probe/probe_struct.rs.html?search=u32+-%3E+bool

Example usage of Probe::find_all_device_properties. It prints each collected file system property, then prints a partition table header and rows with partition number, start, size, and type. Falls back to an error message if no supported properties are found.

```rust
ScanResult::FoundProperties => {
    // Print collected file system properties
    for property in probe.iter_device_properties() {
        println!("{property}")
    }

    // Print metadata about partition table entries
    // Header
    println!("Partition table");
    println!("{} {:>10} {:>10}  {:>10}\n----", "number", "start", "size", "part_type");

    for partition in probe.iter_partitions() {
        let number = partition.number();
        let start = partition.location_in_sectors();
        let size = partition.size_in_sectors();
        let part_type = partition.partition_type();

        // Row
        println!("#{}: {:>10} {:>10}  0x{:x}", number, start, size, part_type)
    }
}
_ => eprintln!("could not find any supported file system properties"),
```

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

### Initialize a Probe and scan for file systems

Source: https://docs.rs/rsblkid/latest/src/rsblkid/probe/probe_struct.rs.html

This example shows how to build a Probe and configure it to scan for specific file systems.

```rust
use rsblkid::partition::FileSystem;
    use rsblkid::probe::{Filter, FsProperty, Probe, ScanResult};

    fn main() -> rsblkid::Result<()> {
        let mut probe = Probe::builder()
            // Assuming `/dev/vda` has an ext4 file system
            .scan_device("/dev/vda")
            // Search device for the following types of file system.
            .scan_superblocks_for_file_systems(Filter::In,
                vec![
                    FileSystem::APFS,
                    FileSystem::NTFS,
                    FileSystem::Ext4,
                    FileSystem::VFAT,
                    FileSystem::ZFS,
                ])
            .build()?;

        // Probe state
        // Legend: [*] has run  [ ] did not run  [#] has matched
        //
        // Before
        //
        // category: superblocks
        //     search function: APFS [ ]
        //     search function: NTFS [ ]
        //     search function: Ext4 [ ]
        //     search function: VFAT [ ]
        //     search function: ZFS  [ ]
        match probe.run_scan() {
            // After
            //
            // category: superblocks
            //     search function: APFS [*]
```

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

### Parse NetBSD GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html?search=

Examples of parsing various NetBSD-specific GUID strings into their corresponding Guid enum variants.

```rust
let guid_str = "49f48d32-b10e-11dc-b99b-0019d1879648";
let actual: Guid = guid_str.parse()?;
let expected = Guid::NetBSDSwap;
assert_eq!(actual, expected);
```

```rust
let guid_str = "49f48d5a-b10e-11dc-b99b-0019d1879648";
let actual: Guid = guid_str.parse()?;
let expected = Guid::NetBSDFFS;
assert_eq!(actual, expected);
```

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

### Parse Solaris GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html?search=

Examples of parsing various Solaris-specific GUID strings into their corresponding Guid enum variants.

```rust
let guid_str = "6a82cb45-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisBoot;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a85cf4d-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisRoot;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a87c46f-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisSwap;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a8b642b-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisBackup;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a898cc3-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisUsr;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a8ef2e9-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisVar;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a90ba39-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisHome;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a9283a5-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisAlternateSector;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a945a3b-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisReserved1;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a9630d1-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisReserved2;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a980767-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisReserved3;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a96237f-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisReserved4;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a8d2ac7-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisReserved5;
assert_eq!(actual, expected);
```

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

### Configure and execute a device probe

Source: https://docs.rs/rsblkid/latest/rsblkid/probe/struct.Probe.html

This example demonstrates how to use the Probe builder to scan a device for specific file systems and partition tables, then iterate over the results.

```rust
fn main() -> rsblkid::Result<()> {
    let mut probe = Probe::builder()
        // Assuming `/dev/vda` has an ext4 file system on a partition,
        // in a GPT partition table
        .scan_device("/dev/vda")
        // Search device for the following types of file system.
        .scan_superblocks_for_file_systems(Filter::In,
            vec![
                FileSystem::APFS,
                FileSystem::NTFS,
                FileSystem::Ext4,
                FileSystem::VFAT,
                FileSystem::ZFS,
            ])
        // Activate partition search functions.
        .scan_device_partitions(true)
        // Search for partition in the following partition tables
        .scan_partitions_for_partition_tables(Filter::In,
            vec![
                PartitionTableType::AIX,
                PartitionTableType::BSD,
                PartitionTableType::GPT,
                PartitionTableType::SGI,
            ])
        .build()?;

    // Probe state
    // Legend: [*] has run  [ ] did not run  [#] has matched
    //
    // Before
    //
    // category: superblocks
    //     search function: APFS [ ]
    //     search function: NTFS [ ]
    //     search function: Ext4 [ ]
    //     search function: VFAT [ ]
    //     search function: ZFS  [ ]
    // category: partitions
    //     search function: AIX  [ ]
    //     search function: BSD  [ ]
    //     search function: GPT  [ ]
    //     search function: SGI  [ ]
    match probe.find_device_properties() {
        // After
        //
        // category: superblocks
        //     search function: APFS [*]
        //     search function: NTFS [*]
        //     search function: Ext4 [#]
        //     search function: VFAT [ ]
        //     search function: ZFS  [ ]
        // category: partitions
        //     search function: AIX  [*]
        //     search function: BSD  [*]
        //     search function: GPT  [#]
        //     search function: SGI  [ ]
        ScanResult::FoundProperties => {
            // Print collected file system properties
            for property in probe.iter_device_properties() {
                println!("{property}")
            }

            // Print metadata about partition table entries
            // Header
            println!("Partition table");
            println!("{} {:>10} {:>10}  {:>10}\n----", "number", "start", "size", "part_type");

            for partition in probe.iter_partitions() {
                let number = partition.number();
                let start = partition.location_in_sectors();
                let size = partition.size_in_sectors();
                let part_type = partition.partition_type();

                // Row
                println!("#{}: {:>10} {:>10}  0x{:x}", number, start, size, part_type)
            }
        }
        _ => eprintln!("could not find any supported file system properties"),
    }

    Ok(())
}
```

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

### Parse macOS GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html?search=

Examples of parsing various macOS-specific GUID strings into their corresponding Guid enum variants.

```rust
let guid_str = "52414944-0000-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSRAID;
assert_eq!(actual, expected);
```

```rust
let guid_str = "52414944-5f4f-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSRAIDOffline;
assert_eq!(actual, expected);
```

```rust
let guid_str = "426f6f74-0000-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSBootRecovery;
assert_eq!(actual, expected);
```

```rust
let guid_str = "4c616265-6c00-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSLabel;
assert_eq!(actual, expected);
```

```rust
let guid_str = "5265636f-7665-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSAppleTVRecovery;
assert_eq!(actual, expected);
```

```rust
let guid_str = "53746f72-6167-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSHFSPlusFileVault;
assert_eq!(actual, expected);
```

```rust
let guid_str = "69646961-6700-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSAPFSPreboot;
assert_eq!(actual, expected);
```

```rust
let guid_str = "52637672-7900-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSAPFSRecovery;
assert_eq!(actual, expected);
```

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

### Cache builder example

Source: https://docs.rs/rsblkid/latest/src/rsblkid/cache/cache_struct.rs.html?search=std%3A%3Avec

Example showing how to initialize a cache and probe devices before performing a tag lookup.

```rust
# use pretty_assertions::assert_eq;
    use std::path::PathBuf;
    use rsblkid::device::Tag;
    use rsblkid::cache::Cache;

    fn main() -> rsblkid::Result<()> {
        let mut cache = Cache::builder()
            .discard_changes_on_drop()
            .build()?;

        cache.probe_all_devices()?;

        let uuid: Tag = r#"UUID="ac4f36bf-191b-4fb0-b808-6d7fc9fc88be""#.parse()?;
```

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

### iter example

Source: https://docs.rs/rsblkid/latest/rsblkid/cache/struct.Cache.html?search=

Shows how to iterate over all device entries in the cache and print their names. Panics if an EntryIter cannot be instantiated.

```rust
use rsblkid::cache::Cache;

fn main() -> rsblkid::Result<()> {
    let mut cache = Cache::builder().discard_changes_on_drop().build()?;
    cache.probe_all_devices()?;

    for device in cache.iter() {
        println!("{}", device.name().display());
    }

    Ok(())
}
```

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

### Parse System GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html

Examples of parsing OpenBSD and QNX6 filesystem GUID strings.

```rust
let guid_str = "824cc7a0-36a8-11e3-890a-952519ad3f61";
let actual: Guid = guid_str.parse()?;
let expected = Guid::OpenBSDData;
assert_eq!(actual, expected);

let guid_str = "cef5a9ad-73bc-4601-89f3-cdeeeee321a1";
let actual: Guid = guid_str.parse()?;
let expected = Guid::QNX6Fs;
```

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

### Probe scan workflow example

Source: https://docs.rs/rsblkid/latest/src/rsblkid/probe/probe_struct.rs.html?search=

An example demonstrating how to configure a probe to scan for specific file systems and partition metadata, including handling scan results.

```rust
use rsblkid::partition::FileSystem;
    use rsblkid::probe::{Filter, FsProperty, Probe, ScanResult};

    fn main() -> rsblkid::Result<()> {
        let mut probe = Probe::builder()
            // Assuming `/dev/vda` has an ext4 file system
            .scan_device("/dev/vda")
            // Search device for the following types of file system.
            .scan_superblocks_for_file_systems(Filter::In,
                vec![
                    FileSystem::APFS,
                    FileSystem::NTFS,
                    FileSystem::Ext4,
                    FileSystem::VFAT,
                    FileSystem::ZFS,
                ])
            .build()?;

        // Probe state
        // Legend: [*] has run  [ ] did not run  [#] has matched
        //
        // Before
        //
        // category: superblocks
        //     search function: APFS [ ]
        //     search function: NTFS [ ]
        //     search function: Ext4 [ ]
        //     search function: VFAT [ ]
        //     search function: ZFS  [ ]
        match probe.run_scan() {
            // After
            //
            // category: superblocks
            //     search function: APFS [*]
            //     search function: NTFS [*]
            //     search function: Ext4 [#] ◁─── last position
            //     search function: VFAT [ ]
            //     search function: Zfs  [ ]
            // category: partitions
            //     search function: AIX  [ ]
            //     search function: BSD  [ ]
            //     search function: GPT  [ ]
            //     search function: SGI  [ ]
            ScanResult::FoundProperties => {
                // Print collected file system properties
                for property in probe.iter_device_properties() {
                    println!("{property}")
                }
            }
            _ => eprintln!("could not find any supported file system properties"),
        }

        // Second function call
        match probe.run_scan() {
            // category: superblocks
            //     search function: Apfs [*]
            //     search function: Ntfs [*]
            //     search function: Ext4 [#]
            //     search function: VFAT [ ]
            //     search function: Zfs  [ ]
            // category: partitions
            //     search function: AIX  [*] ◁─── resumes here
            //     search function: BSD  [*]
            //     search function: GPT  [#] ◁─── last position
            //     search function: SGI  [ ]
            ScanResult::FoundProperties => {
                // Print metadata about partition table entries
                // Header
                println!("Partition table");
                println!("{} {:>10} {:>10}  {:>10}\n----", "number", "start", "size", "part_type");

                for partition in probe.iter_partitions() {
                    let number = partition.number();
                    let start = partition.location_in_sectors();
                    let size = partition.size_in_sectors();
                    let part_type = partition.partition_type();

                    // Row
                    println!("#{}: {:>10} {:>10}  0x{:x}", number, start, size, part_type)
                }
            }
            _ => panic!("could not find any supported partition metadata"),
        }

        Ok(())
    }
```

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

### Parse MacOS Partition GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html?search=

Examples of parsing various MacOS-related partition GUID strings into their respective Guid enum variants.

```rust
let guid_str = "48465300-0000-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSHFSPlus;
assert_eq!(actual, expected);
```

```rust
let guid_str = "7c3457ef-0000-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSAPFS;
assert_eq!(actual, expected);
```

```rust
let guid_str = "55465300-0000-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSUFS;
assert_eq!(actual, expected);
```

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

### Example: Using Probe::run_scan to scan for file systems and partitions

Source: https://docs.rs/rsblkid/latest/rsblkid/probe/struct.Probe.html?search=u32+-%3E+bool

This example demonstrates configuring a Probe to scan a device for specific file systems and partition tables, then calling run_scan twice to retrieve properties and partition metadata. It shows the expected probe state before and after each scan, and how to handle ScanResult variants. The example assumes /dev/vda has an ext4 file system on a GPT partition table.

```rust
use rsblkid::partition::FileSystem;
use rsblkid::partition::PartitionTableType;
use rsblkid::probe::{Filter, Probe, ScanResult};

fn main() -> rsblkid::Result<()> {
    let mut probe = Probe::builder()
        // Assuming `/dev/vda` has an ext4 file system on a partition,
        // in a GPT partition table
        .scan_device("/dev/vda")
        // Search device for the following types of file system.
        .scan_superblocks_for_file_systems(Filter::In,
            vec![
                FileSystem::APFS,
                FileSystem::NTFS,
                FileSystem::Ext4,
                FileSystem::VFAT,
                FileSystem::ZFS,
            ])
        // Activate partition search functions.
        .scan_device_partitions(true)
        // Search for partition in the following partition tables
        .scan_partitions_for_partition_tables(Filter::In,
            vec![
                PartitionTableType::AIX,
                PartitionTableType::BSD,
                PartitionTableType::GPT,
                PartitionTableType::SGI,
            ])
        .build()?;

    // Probe state
    // Legend: [*] has run  [ ] did not run  [#] has matched
    //
    // Before
    //
    // category: superblocks
    //     search function: APFS [ ]
    //     search function: NTFS [ ]
    //     search function: Ext4 [ ]
    //     search function: VFAT [ ]
    //     search function: ZFS  [ ]
    // category: partitions
    //     search function: AIX  [ ]
    //     search function: BSD  [ ]
    //     search function: GPT  [ ]
    //     search function: SGI  [ ]
    match probe.run_scan() {
        // After
        //
        // category: superblocks
        //     search function: APFS [*]
        //     search function: NTFS [*]
        //     search function: Ext4 [#] ◁─── last position
        //     search function: VFAT [ ]
        //     search function: Zfs  [ ]
        // category: partitions
        //     search function: AIX  [ ]
        //     search function: BSD  [ ]
        //     search function: GPT  [ ]
        //     search function: SGI  [ ]
        ScanResult::FoundProperties => {
            // Print collected file system properties
            for property in probe.iter_device_properties() {
                println!("{property}")
            }
        }
        _ => eprintln!("could not find any supported file system properties"),
    }

    // Second function call
    match probe.run_scan() {
        // category: superblocks
        //     search function: Apfs [*]
        //     search function: Ntfs [*]
        //     search function: Ext4 [#]
        //     search function: VFAT [ ]
        //     search function: Zfs  [ ]
        // category: partitions
        //     search function: AIX  [*] ◁─── resumes here
        //     search function: BSD  [*]
        //     search function: GPT  [#] ◁─── last position
        //     search function: SGI  [ ]
        ScanResult::FoundProperties => {
            // Print metadata about partition table entries
            // Header
            println!("Partition table");
            println!("{} {:>10} {:>10}  {:>10}\n----", "number", "start", "size", "part_type");

            for partition in probe.iter_partitions() {
                let number = partition.number();
                let start = partition.location_in_sectors();
                let size = partition.size_in_sectors();
                let part_type = partition.partition_type();

                // Row
                println!("#{}: {:>10} {:>10}  0x{:x}", number, start, size, part_type)
            }
        }
        _ => panic!("could not find any supported partition metadata"),
    }

    Ok(())
}
```

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

### Scan device properties and partitions with Probe

Source: https://docs.rs/rsblkid/latest/rsblkid/probe/struct.Probe.html

This example demonstrates using find_all_device_properties to scan a device, then iterating over the discovered properties and partition table entries.

```rust
match probe.find_all_device_properties() {
        // After
        //
        // category: superblocks
        //     search function: APFS [*]
        //     search function: NTFS [*]
        //     search function: Ext4 [#]
        //     search function: VFAT [*]
        //     search function: ZFS  [*]
        // category: partitions
        //     search function: AIX  [*]
        //     search function: BSD  [*]
        //     search function: GPT  [#]
        //     search function: SGI  [*]
        ScanResult::FoundProperties => {
            // Print collected file system properties
            for property in probe.iter_device_properties() {
                println!("{property}")
            }

            // Print metadata about partition table entries
            // Header
            println!("Partition table");
            println!("{} {:>10} {:>10}  {:>10}\n----", "number", "start", "size", "part_type");

            for partition in probe.iter_partitions() {
                let number = partition.number();
                let start = partition.location_in_sectors();
                let size = partition.size_in_sectors();
                let part_type = partition.partition_type();

                // Row
                println!("#{}: {:>10} {:>10}  0x{:x}", number, start, size, part_type)
            }
        }
        _ => eprintln!("could not find any supported file system properties"),
    }
```

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

### Parse FreeBSD Partition GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html?search=

Examples of parsing various FreeBSD-related partition GUID strings into their respective Guid enum variants.

```rust
let guid_str = "83bd6b9d-7f41-11dc-be0b-001560b84f0f";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDBoot;
assert_eq!(actual, expected);
```

```rust
let guid_str = "516e7cb4-6ecf-11d6-8ff8-00022d09712b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDDisklabel;
assert_eq!(actual, expected);
```

```rust
let guid_str = "516e7cb5-6ecf-11d6-8ff8-00022d09712b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDSwap;
assert_eq!(actual, expected);
```

```rust
let guid_str = "516e7cb6-6ecf-11d6-8ff8-00022d09712b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDUFS;
assert_eq!(actual, expected);
```

```rust
let guid_str = "516e7cb8-6ecf-11d6-8ff8-00022d09712b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDVinum;
assert_eq!(actual, expected);
```

```rust
let guid_str = "516e7cba-6ecf-11d6-8ff8-00022d09712b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDZFS;
assert_eq!(actual, expected);
```

```rust
let guid_str = "74ba7dd9-a689-11e1-bd04-00e081286acf";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDnandfs;
assert_eq!(actual, expected);
```

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

### Initialize a Probe builder

Source: https://docs.rs/rsblkid/latest/rsblkid/probe/struct.Probe.html

Shows the initial setup of a Probe builder with specific file system and partition table filters.

```rust
use rsblkid::partition::FileSystem;
use rsblkid::partition::PartitionTableType;
use rsblkid::probe::{Filter, Probe, ScanResult};

fn main() -> rsblkid::Result<()> {
    let mut probe = Probe::builder()
        // Assuming `/dev/vda` has an ext4 file system on a partition,
        // in a GPT partition table
        .scan_device("/dev/vda")
        // Search device for the following types of file system.
        .scan_superblocks_for_file_systems(Filter::In,
            vec![
                FileSystem::APFS,
                FileSystem::NTFS,
                FileSystem::Ext4,
                FileSystem::VFAT,
                FileSystem::ZFS,
            ])
        // Activate partition search functions.
        .scan_device_partitions(true)
        // Search for partition in the following partition tables
        .scan_partitions_for_partition_tables(Filter::In,
            vec![
                PartitionTableType::AIX,
                PartitionTableType::BSD,
                PartitionTableType::GPT,
                PartitionTableType::SGI,
            ])
        .build()?;
```

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

### Parse Linux Partition GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html?search=

Examples of parsing various Linux-related partition GUID strings into their respective Guid enum variants.

```rust
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigS390;
assert_eq!(actual, expected);
```

```rust
let guid_str = "3f324816-667b-46ae-86ee-9b0c0c6c11b4";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigS390x;
assert_eq!(actual, expected);
```

```rust
let guid_str = "4ede75e2-6ccc-4cc8-b9c7-70334b087510";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigTILEGx;
assert_eq!(actual, expected);
```

```rust
let guid_str = "974a71c0-de41-43c3-be5d-5c5ccd1ad2c0";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigx86;
assert_eq!(actual, expected);
```

```rust
let guid_str = "e7bb33fb-06cf-4e81-8273-e543b413e2e2";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigx86_64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "bc13c2ff-59e6-4262-a352-b275fd6f7172";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxXBOOTLDR;
assert_eq!(actual, expected);
```

```rust
let guid_str = "0657fd6d-a4ab-43c4-84e5-0933c84b4f4f";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxSwap;
assert_eq!(actual, expected);
```

```rust
let guid_str = "e6d6d379-f507-44c2-a23c-238f2a3df928";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxLVM;
assert_eq!(actual, expected);
```

```rust
let guid_str = "933ac7e1-2eb4-4f13-b844-0e14e2aef915";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxHome;
assert_eq!(actual, expected);
```

```rust
let guid_str = "3b8f8425-20e0-4f3b-907f-1a25a76f98e8";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxServerData;
assert_eq!(actual, expected);
```

```rust
let guid_str = "773f91ef-66d4-49b5-bd83-d683bf40ad16";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxPerUserHome;
assert_eq!(actual, expected);
```

```rust
let guid_str = "7ffec5c9-2d00-49b7-8941-3ea10a5586b7";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxPlain;
assert_eq!(actual, expected);
```

```rust
let guid_str = "ca7d7ccb-63ed-4c53-861c-1742536059cc";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxLUKS;
assert_eq!(actual, expected);
```

```rust
let guid_str = "8da63339-0007-60c0-c436-083ac8230908";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxReserved;
assert_eq!(actual, expected);
```

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

### Configure and build a Probe using ProbeBuilder

Source: https://docs.rs/rsblkid/latest/rsblkid/probe/struct.ProbeBuilder.html

This example demonstrates how to use the ProbeBuilder to configure device scanning, including enabling write access, filtering file systems, and setting partition scanning options.

```rust
    let probe = probe_builder
        .scan_device("/dev/vda")
        // Open device in read/write mode. By default, a Probe opens a device in read-only
        // mode.
        .allow_writes()
        // Set bytes per sector.
        .bytes_per_sector(1024)
        // Scan the whole device (i.e. start at byte 0, for a length of 0 which is
        // interpreted as the whole disk).
        .scan_device_segment(0, 0)
        // Activate file system search functions. By default, device superblocks scanning
        // is automatically activated.
        .scan_device_superblocks(true)
        // Specify which file systems to search for when scanning the device, by default all
        // supported file system identification functions are tried.
        .scan_superblocks_for_file_systems(Filter::In,
            [
                FileSystem::APFS,
                FileSystem::Ext4,
                FileSystem::VFAT,
            ])
        // Exclude superblocks with usage flags matching the ones in the list.
        .scan_superblocks_with_usage_flags(Filter::Out,
            [
                Usage::Crypto,
                Usage::Raid
            ])
        // Collect file system properties matching the ones specified.
        .collect_fs_properties(
            [
                FsProperty::Label,
                FsProperty::Uuid,
                FsProperty::FsInfo,
                FsProperty::Version,
            ])
        // Activate partitions search functions. By default, device partitions scanning
        // is NOT active.
        .scan_device_partitions(true)
        // Specify which partition tables to search for when scanning the device, by
        // default all supported partition table identification functions are tried.
        .scan_partitions_for_partition_tables(Filter::In,
            [
                PartitionTableType::AIX,
                PartitionTableType::BSD,
                PartitionTableType::GPT,
                PartitionTableType::DOS,
            ])
        // Set additional data to collect on partitions, and collection methods to use
        .partitions_scanning_options(
            [
                PartitionScanningOption::EntryDetails,
                PartitionScanningOption::ForceGPT,
            ])
        // Activate device topology search functions. By default, device partitions scanning
        // is NOT activate.
        .scan_device_topology(true)
        .build();

    assert!(probe.is_ok());
```

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

### Parse Linux Verity GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html

Examples of parsing specific GUID strings into LinuxUsrVerity variants.

```rust
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityPPC64LE;
assert_eq!(actual, expected);

let guid_str = "cb1ee4e3-8cd0-4136-a0a4-aa61a32e8730";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityRISCV32;
assert_eq!(actual, expected);

let guid_str = "8f1056be-9b05-47c4-81d6-be53128e5b54";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityRISCV64;
assert_eq!(actual, expected);

let guid_str = "b663c618-e7bc-4d6d-90aa-11b756bb1797";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityS390;
assert_eq!(actual, expected);

let guid_str = "31741cc4-1a2a-4111-a581-e00b447d2d06";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityS390x;
assert_eq!(actual, expected);

let guid_str = "2fb4bf56-07fa-42da-8132-6b139f2026ae";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityTILEGx;
assert_eq!(actual, expected);

let guid_str = "8f461b0d-14ee-4e81-9aa9-049b6fb97abd";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityx86;
assert_eq!(actual, expected);

let guid_str = "77ff5f63-e7b6-4633-acf4-1565b864c0e6";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityx86_64;
assert_eq!(actual, expected);
```

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

### Perform a scan and iterate over device properties

Source: https://docs.rs/rsblkid/latest/src/rsblkid/probe/probe_struct.rs.html

This example demonstrates running a scan on a device and iterating over the found file system properties.

```rust
match probe.run_scan() {
        // After
        //
        // category: superblocks
        //     search function: APFS [*]
        //     search function: NTFS [*]
        //     search function: Ext4 [#] ◁─── last position
        //     search function: VFAT [ ]
        //     search function: Zfs  [ ]
        // category: partitions
        //     search function: AIX  [ ]
        //     search function: BSD  [ ]
        //     search function: GPT  [ ]
        //     search function: SGI  [ ]
        ScanResult::FoundProperties => {
            // Print collected file system properties
            for property in probe.iter_device_properties() {
                println!("{property}")
            }
        }
        _ => eprintln!("could not find any supported file system properties"),
    }
```

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

### Parse Ceph Partition GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of parsing GUID strings for Ceph partition types.

```rust
let guid_str = "45b0969e-9b03-4f30-b4c6-b4b80ceff106";
let actual: Guid = guid_str.parse()?;
let expected = Guid::CephJournal;
assert_eq!(actual, expected);
```

```rust
let guid_str = "45b0969e-9b03-4f30-b4c6-5ec00ceff106";
let actual: Guid = guid_str.parse()?;
let expected = Guid::CephDMCryptJournal;
assert_eq!(actual, expected);
```

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

### CacheBuilder::build usage examples

Source: https://docs.rs/rsblkid/latest/src/rsblkid/cache/cache_builder_struct.rs.html?search=

Demonstrates how to instantiate a Cache using the builder pattern with different configuration options.

```rust
    /// use rsblkid::cache::Cache;
    /// use std::error::Error;
    /// use std::path::Path;
    /// use tempfile::NamedTempFile;
    ///
    /// fn main() -> Result<(), Box<dyn Error>> {
    ///
    ///     // Create a cache that automatically saves changes to the default cache file
    ///     // (`blkid.tab`) when dropped.
    ///     let result = Cache::builder().build();
    ///
    ///     assert!(result.is_ok());
    ///
    ///     // Create a cache that automatically saves changes to a custom cache file when dropped.
    ///     let temp_file = NamedTempFile::new()?; // Create a temporary destination file in `/tmp`.
    ///     let result = Cache::builder()
    ///         .auto_save_changes_to(temp_file.path())
    ///         .build();
    ///
    ///     assert!(result.is_ok());
    ///
    ///     // Create a cache that automatically discards changes when dropped.
    ///     let result = Cache::builder().discard_changes_on_drop().build();
    ///
    ///     assert!(result.is_ok());
    ///
    ///     Ok(())
    /// }
```

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

### Parse Haiku Partition GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of parsing a GUID string for a Haiku BFS partition.

```rust
let guid_str = "42465331-3ba3-10f1-802a-4861696b7521";
let actual: Guid = guid_str.parse()?;
let expected = Guid::HaikuBFS;
assert_eq!(actual, expected);
```

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

### Cache::probe_all_devices() example

Source: https://docs.rs/rsblkid/latest/rsblkid/cache/struct.Cache.html?search=

Builds a Cache and probes all block devices, populating the cache. Uses the ? operator to propagate errors.

```rust
use rsblkid::cache::Cache;

fn main() -> rsblkid::Result<()> {
    let mut cache = Cache::builder().build()?;
    cache.probe_all_devices()?;

    Ok(())
}
```

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

### Parse MidnightBSD Partition GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of parsing GUID strings for various MidnightBSD partition types.

```rust
let guid_str = "85d5e45e-237c-11e1-b4b3-e89a8f7fc3a7";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MidnightBSDBoot;
assert_eq!(actual, expected);
```

```rust
let guid_str = "85d5e45a-237c-11e1-b4b3-e89a8f7fc3a7";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MidnightBSDData;
assert_eq!(actual, expected);
```

```rust
let guid_str = "85d5e45b-237c-11e1-b4b3-e89a8f7fc3a7";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MidnightBSDSwap;
assert_eq!(actual, expected);
```

```rust
let guid_str = "0394ef8b-237e-11e1-b4b3-e89a8f7fc3a7";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MidnightBSDUFS;
assert_eq!(actual, expected);
```

```rust
let guid_str = "85d5e45c-237c-11e1-b4b3-e89a8f7fc3a7";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MidnightBSDVinum;
assert_eq!(actual, expected);
```

```rust
let guid_str = "85d5e45d-237c-11e1-b4b3-e89a8f7fc3a7";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MidnightBSDZFS;
assert_eq!(actual, expected);
```

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

### Parse CoreOS Partition GUIDs

Source: https://docs.rs/rsblkid/latest/src/rsblkid/core/partition/guid_enum.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of parsing GUID strings for various CoreOS partition types.

```rust
let guid_str = "5dfbf5f4-2848-4bac-aa5e-0d9a20b745a6";
let actual: Guid = guid_str.parse()?;
let expected = Guid::CoreOSUsr;
assert_eq!(actual, expected);
```

```rust
let guid_str = "3884dd41-8582-4404-b9a8-e9b84f2df50e";
let actual: Guid = guid_str.parse()?;
let expected = Guid::CoreOSResize;
assert_eq!(actual, expected);
```

```rust
let guid_str = "c95dc21a-df0e-4340-8d7b-26cbfa9a03e0";
let actual: Guid = guid_str.parse()?;
let expected = Guid::CoreOSReserved;
assert_eq!(actual, expected);
```

```rust
let guid_str = "be9067b9-ea49-4f15-b4f6-f36f8c9e1818";
let actual: Guid = guid_str.parse()?;
let expected = Guid::CoreOSRootRAID;
assert_eq!(actual, expected);
```