如何从 Rust 中的文件中读取结构？

Question

有没有一种方法可以直接从 Rust 中的文件中读取结构？我的代码是：

use std::fs::File;

struct Configuration {
    item1: u8,
    item2: u16,
    item3: i32,
    item4: [char; 8],
}

fn main() {
    let file = File::open("config_file").unwrap();

    let mut config: Configuration;
    // How to read struct from file?
}

如何将我的配置从文件中直接读入config？这甚至可能吗？

Answer 1

给你：

use std::io::Read;
use std::mem;
use std::slice;

#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
struct Configuration {
    item1: u8,
    item2: u16,
    item3: i32,
    item4: [char; 8],
}

const CONFIG_DATA: &[u8] = &[
    0xfd, // u8
    0xb4, 0x50, // u16
    0x45, 0xcd, 0x3c, 0x15, // i32
    0x71, 0x3c, 0x87, 0xff, // char
    0xe8, 0x5d, 0x20, 0xe7, // char
    0x5f, 0x38, 0x05, 0x4a, // char
    0xc4, 0x58, 0x8f, 0xdc, // char
    0x67, 0x1d, 0xb4, 0x64, // char
    0xf2, 0xc5, 0x2c, 0x15, // char
    0xd8, 0x9a, 0xae, 0x23, // char
    0x7d, 0xce, 0x4b, 0xeb, // char
];

fn main() {
    let mut buffer = CONFIG_DATA;

    let mut config: Configuration = unsafe { mem::zeroed() };

    let config_size = mem::size_of::<Configuration>();
    unsafe {
        let config_slice = slice::from_raw_parts_mut(&mut config as *mut _ as *mut u8, config_size);
        // `read_exact()` comes from `Read` impl for `&[u8]`
        buffer.read_exact(config_slice).unwrap();
    }

    println!("Read structure: {:#?}", config);
}

Try it here（针对 Rust 1.38 更新）

但是，您需要小心，因为不安全的代码是不安全的。在slice::from_raw_parts_mut() 调用之后，同一数据同时存在两个可变句柄，这违反了Rust 别名规则。因此，您可能希望将在结构之外创建的可变切片保留尽可能短的时间。我还假设您了解字节序问题 - 上面的代码绝不是可移植的，如果在不同类型的机器（例如 ARM 与 x86）上编译和运行，将返回不同的结果。

如果您可以选择格式并且想要紧凑的二进制格式，请考虑使用bincode。否则，如果您需要，例如要解析一些预定义的二进制结构，byteorder crate 是要走的路。

Answer 2

作为Vladimir Matveev mentions，使用the byteorder crate 通常是最好的解决方案。这样，您就可以解决字节顺序问题，不必处理任何不安全的代码，也不必担心对齐或填充：

use byteorder::{LittleEndian, ReadBytesExt}; // 1.2.7
use std::{
    fs::File,
    io::{self, Read},
};

struct Configuration {
    item1: u8,
    item2: u16,
    item3: i32,
}

impl Configuration {
    fn from_reader(mut rdr: impl Read) -> io::Result<Self> {
        let item1 = rdr.read_u8()?;
        let item2 = rdr.read_u16::<LittleEndian>()?;
        let item3 = rdr.read_i32::<LittleEndian>()?;

        Ok(Configuration {
            item1,
            item2,
            item3,
        })
    }
}

fn main() {
    let file = File::open("/dev/random").unwrap();

    let config = Configuration::from_reader(file);
    // How to read struct from file?
}

我忽略了[char; 8] 有几个原因：

1. Rust 的 char 是 32 位类型，不清楚您的文件是否具有实际的 Unicode 代码点或 C 样式的 8 位值。
2. 你不能轻易地用字节序解析数组，你必须先解析 N 个值，然后自己构建数组。

Answer 3

以下代码未考虑任何endianness 或padding 问题，旨在与POD types 一起使用。 struct Configuration 在这种情况下应该是安全的。

---

这是一个可以从文件中读取结构（POD 类型）的函数：

use std::io::{self, Read};
use std::slice;

fn read_struct<T, R: Read>(mut read: R) -> io::Result<T> {
    let num_bytes = ::std::mem::size_of::<T>();
    unsafe {
        let mut s = ::std::mem::uninitialized();
        let buffer = slice::from_raw_parts_mut(&mut s as *mut T as *mut u8, num_bytes);
        match read.read_exact(buffer) {
            Ok(()) => Ok(s),
            Err(e) => {
                ::std::mem::forget(s);
                Err(e)
            }
        }
    }
}

// use
// read_struct::<Configuration>(reader)

如果要从文件中读取一系列结构体，可以多次执行read_struct或一次读取所有文件：

use std::fs::{self, File};
use std::io::BufReader;
use std::path::Path;

fn read_structs<T, P: AsRef<Path>>(path: P) -> io::Result<Vec<T>> {
    let path = path.as_ref();
    let struct_size = ::std::mem::size_of::<T>();
    let num_bytes = fs::metadata(path)?.len() as usize;
    let num_structs = num_bytes / struct_size;
    let mut reader = BufReader::new(File::open(path)?);
    let mut r = Vec::<T>::with_capacity(num_structs);
    unsafe {
        let buffer = slice::from_raw_parts_mut(r.as_mut_ptr() as *mut u8, num_bytes);
        reader.read_exact(buffer)?;
        r.set_len(num_structs);
    }
    Ok(r)
}

// use
// read_structs::<StructName, _>("path/to/file"))