Как правильно читать двоичный файл в чанках фиксированного размера и сохранять все эти чанки в Vec?

Question

У меня проблемы с открытием файла. Большинство примеров считывают файлы в String или читают весь файл в Vec. Мне нужно прочитать файл в чанки фиксированного размера и сохранить эти чанки в массив (Vec) чанков.

Например, у меня есть файл с именем my_file размером точно 64 КБ, и я хочу прочитать его кусками по 16 КБ, поэтому я получу Vec размера 4, где каждый элемент является другим Vec с размером 16Kb (0x4000 байт).

После прочтения документации и проверки ответов на переполнение стека я смог получить что-то вроде этого:

let mut file = std::fs::File::open("my_file")?;
// ...calculate num_of_chunks 4 in this case
let list_of_chunks = Vec::new();

for chunk in 0..num_of_chunks {
    let mut data: [u8; 0x4000] = [0; 0x4000];
    file.read(&mut data[..])?;
    list_of_chunks.push(data.to_vec());
}

Хотя это, кажется, работает нормально, выглядит немного запутанным. Я читаю:

• Для каждой итерации создайте новый массив в стеке
• Чтение фрагмента в массив
• Скопируйте содержимое массива в новый Vec, а затем переместите Vec в list_of_chunks Vec.

Я не уверен, что это идиоматично или вообще возможно, но я бы предпочел что-то вроде этого:

• Создайте Vec с num_of_chunk элементами, где каждый элемент является другим Vec размером 16 КБ.
• Считать файловый блок прямо в правильный Vec

Нет копирования, и мы проследим, чтобы перед чтением файла была выделена память.

Возможен ли такой подход? или есть лучший обычный / идиоматический / правильный способ сделать это? Мне интересно, если Vec правильный тип для решения этой проблемы. Я имею в виду, мне не нужно будет увеличивать массив после прочтения файла.

Answer 1

Read::read_to_end эффективно считывает Vec.Если вы хотите использовать его в виде кусков, объедините его с Read::take, чтобы ограничить количество байтов, которое будет читать read_to_end.

Пример:

let mut file = std::fs::File::open("your_file")?;

let mut list_of_chunks = Vec::new();

let chunk_size = 0x4000;

loop {
    let mut chunk = Vec::with_capacity(chunk_size);
    let n = file.by_ref().take(chunk_size as u64).read_to_end(&mut chunk)?;
    if n == 0 { break; }
    list_of_chunks.push(chunk);
    if n < chunk_size { break; }
}

последний if не обязателен, но он предотвращает дополнительный вызов read: если read_to_end было прочитано меньше запрашиваемого количества байтов, мы можем ожидать, что следующий read ничего не прочитает, так как мы достигли концафайла.

Answer 2

Я думаю, что самый идиоматический способ - использовать итератор. Код ниже (свободно вдохновленный ответом M-ou-se ):

• Обрабатывает многие варианты использования с использованием универсальных типов
• Будет использоваться предварительно выделенный вектор
• Скрывает побочный эффект
• Избегайте копирования данных дважды

use std::io::{self, Read, Seek, SeekFrom};

struct Chunks<R> {
    read: R,
    size: usize,
    hint: (usize, Option<usize>),
}

impl<R> Chunks<R> {
    pub fn new(read: R, size: usize) -> Self {
        Self {
            read,
            size,
            hint: (0, None),
        }
    }

    pub fn from_seek(mut read: R, size: usize) -> io::Result<Self>
    where
        R: Seek,
    {
        let old_pos = read.seek(SeekFrom::Current(0))?;
        let len = read.seek(SeekFrom::End(0))?;

        let rest = (len - old_pos) as usize; // len is always >= old_pos but they are u64
        if rest != 0 {
            read.seek(SeekFrom::Start(old_pos))?;
        }

        let min = rest / size + if rest % size != 0 { 1 } else { 0 };
        Ok(Self {
            read,
            size,
            hint: (min, None), // this could be wrong I'm unsure
        })
    }

    // This could be useful if you want to try to recover from an error
    pub fn into_inner(self) -> R {
        self.read
    }
}

impl<R> Iterator for Chunks<R>
where
    R: Read,
{
    type Item = io::Result<Vec<u8>>;

    fn next(&mut self) -> Option<Self::Item> {
        let mut chunk = Vec::with_capacity(self.size);
        match self
            .read
            .by_ref()
            .take(chunk.capacity() as u64)
            .read_to_end(&mut chunk)
        {
            Ok(n) => {
                if n != 0 {
                    Some(Ok(chunk))
                } else {
                    None
                }
            }
            Err(e) => Some(Err(e)),
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.hint
    }
}

trait ReadPlus: Read {
    fn chunks(self, size: usize) -> Chunks<Self>
    where
        Self: Sized,
    {
        Chunks::new(self, size)
    }
}

impl<T: ?Sized> ReadPlus for T where T: Read {}

fn main() -> io::Result<()> {
    let file = std::fs::File::open("src/main.rs")?;
    let iter = Chunks::from_seek(file, 0xFF)?; // replace with anything 0xFF was to test

    println!("{:?}", iter.size_hint());
    // This iterator could return Err forever be careful collect it into an Result
    let chunks = iter.collect::<Result<Vec<_>, _>>()?;
    println!("{:?}, {:?}", chunks.len(), chunks.capacity());

    Ok(())
}