Function error_retry_indirect_closure

examples/buffer_errors.rs:89–136

()

}

fn error_retry_indirect_closure() {
    use rustix::buffer::Buffer;
    use rustix::io;
    let flag = true;

    // This is reduced from the xattr crate, src/sys/linux_macos.rs line 119.

    // Ideally we'd write this, but it gets:
    // "borrowed data escapes outside of closure".
    /*
    let func = if flag {
        f
    } else {
        g
    };
    let _vec = allocate_loop(|buf| func(buf)).unwrap();
    */

    // The fix: Move `func` to inside the closure.
    let _vec = allocate_loop(|buf| {
        let func = if flag { f } else { g };
        func(buf)
    })
    .unwrap();

    fn allocate_loop<F: FnMut(&mut [u8]) -> io::Result<usize>>(mut f: F) -> io::Result<Vec<u8>> {
        let mut vec: Vec<u8> = Vec::new();
        loop {
            let ret = f(&mut [])?;
            vec.resize(ret, 0);

            match f(&mut vec) {
                Ok(size) => {
                    vec.truncate(size);
                    vec.shrink_to_fit();
                    return Ok(vec);
                }
                Err(err) => return Err(err),
            }
        }
    }
    fn f<B: Buffer<u8>>(_: B) -> Result<usize, io::Errno> {
        Ok(0)
    }
    fn g<B: Buffer<u8>>(_: B) -> Result<usize, io::Errno> {
        Ok(0)
    }
}

fn error_empty_slice() {
    use rustix::buffer::Buffer;