SMBIOS Library

https://docs.rs/smbios-lib/0.9.2
Admin
A Rust library implementing the DMTF System Management BIOS (SMBIOS) Reference Specification 3.5.0...
Tokens:460,938
Snippets:6,811
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### limit() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.Take.html

Example demonstrating how to get the byte limit of a Take instance.

```rust
use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let f = File::open("foo.txt")?;

    // read at most five bytes
    let handle = f.take(5);

    println!("limit: {}", handle.limit());
    Ok(())
}
```

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

### Example of using path()

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.DirEntry.html

Demonstrates how to get the full path of a directory entry.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    for entry in fs::read_dir(".")? {
        let dir = entry?;
        println!("{:?}", dir.path());
    }
    Ok(())
}
```

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

### Example usage

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/fn.create_dir_all.html

Example of how to use create_dir_all.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    fs::create_dir_all("/some/dir")?;
    Ok(())
}

```

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

### permissions() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.Metadata.html

Example of how to get file permissions from metadata.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    let metadata = fs::metadata("foo.txt")?;

    assert!(!metadata.permissions().readonly());
    Ok(())
}
```

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

### pad example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/struct.Formatter.html

Example demonstrating the usage of the `pad` method.

```rust
use std::fmt;

struct Foo;

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.pad("Foo")
    }
}

assert_eq!(format!("{{Foo:<4}}"), "Foo ");
assert_eq!(format!("{{Foo:0>4}}"), "0Foo");

```

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

### get_ref() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.Take.html

Example demonstrating how to get an immutable reference to the underlying reader.

```rust
use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let mut file = File::open("foo.txt")?;

    let mut buffer = [0; 5];
    let mut handle = file.take(5);
    handle.read(&mut buffer)?;

    let file = handle.get_ref();
    Ok(())
}
```

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

### Example usage

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/fn.copy.html

Example of how to use the copy function.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    fs::copy("foo.txt", "bar.txt")?;  // Copy foo.txt to bar.txt
    Ok(())
}

```

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

### write_fmt example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/struct.Formatter.html

Example demonstrating the usage of the `write_fmt` method.

```rust
use std::fmt;

struct Foo(i32);

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_fmt(format_args!("Foo {}", self.0))
    }
}

assert_eq!(format!("{}", Foo(-1)), "Foo -1");
assert_eq!(format!("{:0>8}", Foo(2)), "Foo 2");

```

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

### width() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/struct.Formatter.html

Illustrates using the `width()` method to get the specified output width and apply it for padding.

```rust
use std::fmt;

struct Foo(i32);

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(width) = formatter.width() {
            // If we received a width, we use it
            write!(formatter, "{:width$}", format!("Foo({})", self.0), width = width)
        } else {
            // Otherwise we do nothing special
            write!(formatter, "Foo({})", self.0)
        }
    }
}

assert_eq!(format!("{:10}", Foo(23)), "Foo(23)   ");
assert_eq!(format!("{}", Foo(23)), "Foo(23)");

```

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

### Examples

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/fn.write.html

Example usage of the `fs::write` function.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    fs::write("foo.txt", b"Lorem ipsum")?;
    fs::write("bar.txt", "dolor sit")?;
    Ok(())
}

```

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

### pad_integral example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/struct.Formatter.html

Example demonstrating the usage of the `pad_integral` method.

```rust
use std::fmt;

struct Foo {
    nb: i32,
}

impl Foo {
    fn new(nb: i32) -> Foo {
        Foo {
            nb,
        }
    }
}

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        // We need to remove "-" from the number output.
        let tmp = self.nb.abs().to_string();

        formatter.pad_integral(self.nb >= 0, "Foo ", &tmp)
    }
}

assert_eq!(format!("{}", Foo::new(2)), "2");
assert_eq!(format!("{}", Foo::new(-1)), "-1");
assert_eq!(format!("{}", Foo::new(0)), "0");
assert_eq!(format!("{:#}", Foo::new(-1)), "-Foo 1");
assert_eq!(format!("{:0>#8}", Foo::new(-1)), "00-Foo 1");

```

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

### write_str example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/struct.Formatter.html

Example demonstrating the usage of the `write_str` method.

```rust
use std::fmt;

struct Foo;

impl fmt::Display for Foo {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str("Foo")
        // This is equivalent to:
        // write!(formatter, "Foo")
    }
}

assert_eq!(format!("{{Foo}}"), "Foo");
assert_eq!(format!("{{Foo:0>8}}"), "Foo");

```

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

### Example of getting a reference to the underlying reader

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.BufReader.html

This example shows how to get a reference to the underlying reader of a BufReader.

```rust
use std::io::BufReader;
use std::fs::File;

fn main() -> std::io::Result<()> {
    let f1 = File::open("log.txt")?;
    let reader = BufReader::new(f1);

    let f2 = reader.get_ref();
    Ok(())
}
```

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

### Example of getting the internally buffered data

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.BufReader.html

This example shows how to get a reference to the internally buffered data of a BufReader.

```rust
use std::io::{BufReader, BufRead};
use std::fs::File;

fn main() -> std::io::Result<()> {
    let f = File::open("log.txt")?;
    let mut reader = BufReader::new(f);
    assert!(reader.buffer().is_empty());

    if reader.fill_buf()?.len() > 0 {
        assert!(!reader.buffer().is_empty());
    }
    Ok(())
}
```

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

### Basic File Creation Example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.OpenOptions.html

Example of creating a new file with write permissions.

```rust
use std::fs::OpenOptions;

let file = OpenOptions::new().write(true).create(true).open("foo.txt");
```

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

### options example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.File.html

Returns a new OpenOptions object. This function returns a new OpenOptions object that you can use to open or create a file with specific options if `open()` or `create()` are not appropriate. It is equivalent to `OpenOptions::new()`, but allows you to write more readable code.

```rust
use std::fs::File;
use std::io::Write;

fn main() -> std::io::Result<()> {
    let mut f = File::options().append(true).open("example.log")?;
    writeln!(&mut f, "new line")?;
    Ok(())
}

```

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

### Example of getting a mutable reference to the underlying reader

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.BufReader.html

This example demonstrates how to get a mutable reference to the underlying reader of a BufReader.

```rust
use std::io::BufReader;
use std::fs::File;

fn main() -> std::io::Result<()> {
    let f1 = File::open("log.txt")?;
    let mut reader = BufReader::new(f1);

    let f2 = reader.get_mut();
    Ok(())
}
```

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

### created() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.Metadata.html

Example of how to get the creation time from metadata.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    let metadata = fs::metadata("foo.txt")?;

    if let Ok(time) = metadata.created() {
        println!("{time:?}");
    } else {
        println!("Not supported on this platform");
    }
    Ok(())
}
```

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

### Examples

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/fn.from_fn.html

Demonstrates the usage of fmt::from_fn for custom formatting.

```rust
use std::fmt;

let value = 'a';
assert_eq!(format!("{}", value), "a");
assert_eq!(format!("{:?}", value), "'a'");

let wrapped = fmt::from_fn(|f| write!(f, "{value:?}"));
assert_eq!(format!("{}", wrapped), "'a'");
assert_eq!(format!("{:?}", wrapped), "'a'");

```

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

### Example of using metadata()

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.DirEntry.html

Shows how to retrieve metadata for a directory entry.

```rust
use std::fs;

if let Ok(entries) = fs::read_dir(".") {
    for entry in entries {
        if let Ok(entry) = entry {
            // Here, `entry` is a `DirEntry`.
            if let Ok(metadata) = entry.metadata() {
                // Now let's show our entry's permissions!
                println!("{:?}: {:?}", entry.path(), metadata.permissions());
            } else {
                println!("Couldn't get metadata for {:?}", entry.path());
            }
        }
    }
}
```

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

### Create New File Example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.OpenOptions.html

Example of creating a new file using `create_new(true)`, which fails if the file already exists.

```rust
use std::fs::OpenOptions;

let file = OpenOptions::new().write(true)
                             .create_new(true)
                             .open("foo.txt");
```

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

### file_type() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.Metadata.html

Example of how to get the file type from metadata.

```rust
fn main() -> std::io::Result<()> {
    use std::fs;

    let metadata = fs::metadata("foo.txt")?;

    println!("{:?}", metadata.file_type());
    Ok(())
}
```

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

### Example usage

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/fn.symlink_metadata.html

Example of how to use symlink_metadata to get file attributes.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    let attr = fs::symlink_metadata("/some/file/path.txt")?;
    // inspect attr ...
    Ok(())
}

```

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

### Example Usage

Source: https://docs.rs/smbios-lib/0.9.2/src/smbioslib/structs/types/out_of_band_remote_access.rs.html

Demonstrates how to create and use the SMBiosOutOfBandRemoteAccess structure.

```rust
let struct_type41 = [
            30, 0x06, 0x3B, 0x00, 0x01, 0x03, 0x69, 0x6A, 0x6B, 0x6C, 0x00, 0x00,
        ];

        let parts = UndefinedStruct::new(&struct_type41);
        let test_struct = SMBiosOutOfBandRemoteAccess::new(&parts);

        assert_eq!(
            test_struct.manufacturer_name().to_string(),
            "ijkl".to_string()
        );

        let connections = test_struct.connections().unwrap();
        assert!(connections.inbound_connection_enabled());
        assert!(connections.outbound_connection_enabled());
        assert_eq!(connections.raw, 0x03);
```

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

### get_mut() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.Take.html

Example demonstrating how to get a mutable reference to the underlying reader.

```rust
use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let mut file = File::open("foo.txt")?;

    let mut buffer = [0; 5];
    let mut handle = file.take(5);
    handle.read(&mut buffer)?;

    let file = handle.get_mut();
    Ok(())
}
```

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

### System Power Controls Example

Source: https://docs.rs/smbios-lib/0.9.2/src/smbioslib/structs/types/system_power_controls.rs.html

Example demonstrating the creation and usage of the SMBiosSystemPowerControls structure.

```rust
let struct_type25 = vec![
            0x19, 0x09, 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        ];

        let parts = UndefinedStruct::new(&struct_type25);
        let test_struct = SMBiosSystemPowerControls::new(&parts);

        assert_eq!(test_struct.next_scheduled_power_on_month(), Some(0));
        assert_eq!(test_struct.next_scheduled_power_on_day_of_month(), Some(0));
        assert_eq!(test_struct.next_scheduled_power_on_hour(), Some(0));
        assert_eq!(test_struct.next_scheduled_power_on_minute(), Some(0));
        assert_eq!(test_struct.next_scheduled_power_on_second(), Some(0));
```

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

### accessed() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.Metadata.html

Example of how to get the last access time from metadata.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    let metadata = fs::metadata("foo.txt")?;

    if let Ok(time) = metadata.accessed() {
        println!("{time:?}");
    } else {
        println!("Not supported on this platform");
    }
    Ok(())
}
```

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

### modified() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.Metadata.html

Example of how to get the last modification time from metadata.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    let metadata = fs::metadata("foo.txt")?;

    if let Ok(time) = metadata.modified() {
        println!("{time:?}");
    } else {
        println!("Not supported on this platform");
    }
    Ok(())
}
```

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

### Example of using File::read

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/prelude/trait.Read.html

Demonstrates how to open a file, read up to 10 bytes into a buffer, and print the bytes read.

```Rust
use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let mut f = File::open("foo.txt")?;
    let mut buffer = [0; 10];

    // read up to 10 bytes
    let n = f.read(&mut buffer[..])?;

    println!("The bytes: {:?}", &buffer[..n]);
    Ok(())
}
```

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

### len() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.Metadata.html

Example of how to get the size of a file in bytes from metadata.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    let metadata = fs::metadata("foo.txt")?;

    assert_eq!(0, metadata.len());
    Ok(())
}
```

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

### set_limit() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.Take.html

Example demonstrating how to set a new byte limit for a Take instance.

```rust
use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let f = File::open("foo.txt")?;

    // read at most five bytes
    let mut handle = f.take(5);
    handle.set_limit(10);

    assert_eq!(handle.limit(), 10);
    Ok(())
}
```

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

### Cursor::position example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.Cursor.html

Example demonstrating how to get and manipulate the current position of the Cursor.

```Rust
use std::io::prelude::*;
use std::io::SeekFrom;
use std::io::Cursor;

let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);

assert_eq!(buff.position(), 0);

buff.seek(SeekFrom::Current(2)).unwrap();
assert_eq!(buff.position(), 2);

buff.seek(SeekFrom::Current(-1)).unwrap();
assert_eq!(buff.position(), 1);
```

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

### Cursor::new example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.Cursor.html

Example showing how to create a new Cursor wrapping an empty Vec.

```Rust
use std::io::Cursor;

let buff = Cursor::new(Vec::new());
```

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

### Width Parameter Examples

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/index.html

Provides examples of using the width parameter for minimum width formatting.

```Rust
println!("Hello {:5}!", "x");
```

```Rust
println!("Hello {:1$}!", "x", 5);
```

```Rust
println!("Hello {1:0$}!", 5, "x");
```

```Rust
println!("Hello {:width$}!", "x", width = 5);
```

```Rust
let width = 5;
println!("Hello {:width$}!", "x");
```

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

### Example usage

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/fn.metadata.html

Example of how to use the metadata function to get file attributes.

```rust
use std::fs;

fn main() -> std::io::Result<()> {
    let attr = fs::metadata("/some/file/path.txt")?;
    // inspect attr ...
    Ok(())
}

```

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

### Example: Getting a reference to the underlying writer

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.BufWriter.html

Demonstrates getting an immutable reference to the underlying writer of a BufWriter.

```rust
use std::io::BufWriter;
use std::net::TcpStream;

let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());

// we can use reference just like buffer
let reference = buffer.get_ref();
```

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

### Cursor::get_mut example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.Cursor.html

Example showing how to get a mutable reference to the underlying buffer of a Cursor.

```Rust
use std::io::Cursor;

let mut buff = Cursor::new(Vec::new());

let reference = buff.get_mut();
```

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

### Creates a new file and write bytes to it

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.File.html

Example demonstrating how to create a new file and write bytes to it using `File::create` and `write_all`.

```rust
use std::fs::File;
use std::io::prelude::*;

fn main() -> std::io::Result<()> {
    let mut file = File::create("foo.txt")?;
    file.write_all(b"Hello, world!")?;
    Ok(())
}
```

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

### Creating a blank new set of options

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.OpenOptions.html

This example demonstrates how to create a new `OpenOptions` instance.

```Rust
use std::fs::OpenOptions;

let mut options = OpenOptions::new();
let file = options.read(true).open("foo.txt");
```

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

### Cursor::get_ref example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.Cursor.html

Example showing how to get an immutable reference to the underlying buffer of a Cursor.

```Rust
use std::io::Cursor;

let buff = Cursor::new(Vec::new());

let reference = buff.get_ref();
```

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

### Example: Unwrapping BufWriter to get the inner writer

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.BufWriter.html

Demonstrates unwrapping a BufWriter to get the underlying writer after flushing the buffer.

```rust
use std::io::BufWriter;
use std::net::TcpStream;

let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());

// unwrap the TcpStream and flush the buffer
let stream = buffer.into_inner().unwrap();
```

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

### Examples

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/struct.DebugMap.html

Demonstrates formatting a DebugMap with all elements included.

```rust
use std::fmt;

struct Foo(Vec<(String, i32)>);

impl fmt::Debug for Foo {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_map()
           .entries(self.0.iter().map(|&(ref k, ref v)| (k, v)))
           .finish() // Ends the map formatting.
    }
}

assert_eq!(
    format!(r#"{:?}"#, Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
    r#"{{\"A\": 10, \"B\": 11}}"#, // Corrected escape for inner quotes
);

```

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

### Splitting off a slice starting with the third element

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.IoSliceMut.html

Demonstrates splitting a mutable slice to get a sub-slice starting from a specific index.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

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

### Example: Getting a mutable reference to the underlying writer

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.BufWriter.html

Demonstrates getting a mutable reference to the underlying writer of a BufWriter. It is inadvisable to directly write to the underlying writer.

```rust
use std::io::BufWriter;
use std::net::TcpStream;

let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());

// we can use reference just like buffer
let reference = buffer.get_mut();
```

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

### Format Macro Usage Examples

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/index.html

Examples demonstrating the usage of the format! macro for string formatting.

```rust
format!("Hello");                 // => "Hello"
format!("Hello, {}!", "world");   // => "Hello, world!"
format!("The number is {}", 1);   // => "The number is 1"
format!("{:?}", (3, 4));          // => "(3, 4)"
format!("{value}", value=4);      // => "4"
let people = "Rustaceans";
format!("Hello {people}!");       // => "Hello Rustaceans!"
format!("{} {}", 1, 2);           // => "1 2"
format!("{:04}", 42);             // => "0042" with leading zeros
format!("{:#?}", (100, 200));     // => "(
                                  //       100,
                                  //       200,
                                  //     )"
```

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

### Fill and Alignment Examples

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/index.html

Demonstrates various fill characters and alignment options (<, ^, >) for string formatting in Rust.

```rust
assert_eq!(format!("Hello {:<5}!", "x"),  "Hello x    !");
assert_eq!(format!("Hello {:-<5}!", "x"), "Hello x----!");
assert_eq!(format!("Hello {:^5}!", "x"),  "Hello   x  !");
assert_eq!(format!("Hello {:>5}!", "x"),  "Hello     x!");
```

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

### last_mut

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.IoSliceMut.html

Example of getting a mutable reference to the last element of a slice.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.last_mut());
```

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

### pub fn create<P>(path: P) -> Result<File, Error>

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.File.html

Example of creating a file and writing bytes to it.

```rust
use std::fs::File;
use std::io::Write;

fn main() -> std::io::Result<()> {
    let mut f = File::create("foo.txt")?;
    f.write_all(&1234_u32.to_be_bytes())?;
    Ok(())
}
```

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

### first_mut

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.IoSliceMut.html

Example of getting a mutable reference to the first element of a slice.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.first_mut());
```

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

### Example for `split_off_last`

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.IoSliceMut.html

Demonstrates removing and getting a reference to the last element of a slice.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');
```

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

### Named Parameters Examples

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/index.html

Illustrates the usage of named parameters in the format! macro.

```Rust
format!("{argument}", argument = "test");
```

```Rust
format!("{name} {}", 1, name = 2);
```

```Rust
format!("{a} {c} {b}", a="a", b='b', c=3);
```

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

### Example for `split_off_first`

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.IoSliceMut.html

Demonstrates removing and getting a reference to the first element of a slice.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

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

### sync_all example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.File.html

Attempts to sync all OS-internal file content and metadata to disk. This function will attempt to ensure that all in-memory data reaches the filesystem before returning.

```rust
use std::fs::File;
use std::io::prelude::*;

fn main() -> std::io::Result<()> {
    let mut f = File::create("foo.txt")?;
    f.write_all(b"Hello, world!")?;

    f.sync_all()?;
    Ok(())
}

```

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

### buffer() Example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.BufWriter.html

Demonstrates how to get the number of bytes currently buffered by BufWriter.

```rust
use std::io::BufWriter;
use std::net::TcpStream;

let buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());

// See how many bytes are currently buffered
let bytes_buffered = buf_writer.buffer().len();
```

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

### chunks_mut Example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.IoSliceMut.html

Demonstrates how to use chunks_mut to get mutable references to non-overlapping sub-slices.

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

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

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

### into_inner() example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.Take.html

Example demonstrating how to consume a Take instance and retrieve the underlying reader.

```rust
use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let mut file = File::open("foo.txt")?;

    let mut buffer = [0; 5];
    let mut handle = file.take(5);
    handle.read(&mut buffer)?;

    let file = handle.into_inner();
    Ok(())
}
```

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

### first_chunk_mut

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.IoSliceMut.html

Example of getting a mutable array reference to the first N items in a slice.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_chunk_mut::<2>() {
    first[0] = 5;
    first[1] = 4;
}
assert_eq!(x, &[5, 4, 2]);

assert_eq!(None, x.first_chunk_mut::<4>());
```

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

### Windows SMBIOS Example

Source: https://docs.rs/smbios-lib/0.9.2/src/smbioslib/windows/mod.rs.html

Example of how to load and print SMBIOS data on Windows.

```rust
1//! Windows SMBIOS.
1//! 
1//! Functions and structures for working with SMBIOS on Windows.
1//! 
1//! # Example
1ః ```rust
1ః #[cfg(target_family = "windows")]
1ః #[test]
1ః fn windows_dump() {
1ః     match load_windows_smbios_data() {
1ః         Ok(windows_data) => {
1ః             println!("windows_data: {:#?}", windows_data);
1ః         }
1ః         Err(err) => panic!("failure: {:?}", err),
1ః     }
1ః }
1ః ```
1ః 
1ః mod win_struct;
1ః 
1ః #[cfg(target_family = "windows")]
1ః mod platform;
1ః 
1ః pub use win_struct::*;
1ః 
1ః #[cfg(target_family = "windows")]
1ః pub use platform::*;
1ః 
1ః pub use std::convert::TryInto;
1ః pub use std::{fmt, fs, io};

```

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

### Iterating over lines from stdin

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.Stdin.html

An example showing how to get an iterator over lines from stdin.

```rust
use std::io;

let lines = io::stdin().lines();
for line in lines {
    println!(ירתgot a line: {}ירת, line.unwrap());
}
```

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

### Opening a file for both reading and writing, as well as creating it if it doesn’t exist

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.OpenOptions.html

This example shows how to open a file for both reading and writing, and create it if it doesn't exist.

```Rust
use std::fs::OpenOptions;

let file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .open("foo.txt");
```

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

### BufReader capacity and buffer example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/io/struct.BufReader.html

Demonstrates how to get the capacity of the BufReader and access its buffer.

```rust
use std::io::{BufReader, BufRead};
use std::fs::File;

fn main() -> std::io::Result<()> {
    let f = File::open("log.txt")?;
    let mut reader = BufReader::new(f);

    let capacity = reader.capacity();
    let buffer = reader.fill_buf()?;
    assert!(buffer.len() <= capacity);
    Ok(())
}
```

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

### Formatting Parameters Example

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fmt/index.html

Demonstrates the use of formatting parameters, specifically the 'e' and 'p' format specifiers and the colon separator.

```Rust
let a = 5;
let b = &a;
println!("{a:e} {b:p}");
```

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

### Example of using file_type()

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.DirEntry.html

Illustrates how to get the file type of a directory entry.

```rust
use std::fs;

if let Ok(entries) = fs::read_dir(".") {
    for entry in entries {
        if let Ok(entry) = entry {
            // Here, `entry` is a `DirEntry`.
            if let Ok(file_type) = entry.file_type() {
                // Now let's show our entry's file type!
                println!("{:?}: {:?}", entry.path(), file_type);
            } else {
                println!("Couldn't get file type for {:?}", entry.path());
            }
        }
    }
}
```

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

### Using a buffered Reader

Source: https://docs.rs/smbios-lib/0.9.2/smbioslib/fs/struct.File.html

Example demonstrating how to use a buffered reader with `BufReader` for efficient file reading.

```rust
use std::fs::File;
use std::io::BufReader;
use std::io::prelude::*;

fn main() -> std::io::Result<()> {
    let file = File::open("foo.txt")?;
    let mut buf_reader = BufReader::new(file);
    let mut contents = String::new();
    buf_reader.read_to_string(&mut contents)?;
    assert_eq!(contents, "Hello, world!");
    Ok(())
}
```
Tokens:
Raw