Making a std::io::Write-consuming function write into memory

I'm trying to use a crate that takes ownership of anything that implements std::io::Write to write into, but I want to get the data it writes in memory for further processing, rather than writing it straight to disk. The crate I'm trying to use is ciborium if it's relevant.

The closest I've gotten to success is to pass in a &mut [u8] as the writer, as in this toy demonstration of the general problem:

use std::io::Write;

fn write_stuff<W: Write>(mut w: W) {
    w.write_all(b"Hello\0Rust!").unwrap();
}

fn main() {
    let mut v = [0u8; 20];
    
    write_stuff(&mut v[..]);
    
    dbg!(v);
}

This works, insofar as I can see the bytes that have been read, but has the rather painful flaw that I can't tell how much data was actually written into the slice. This is a serious problem for my case, as the data being serialized may very well include 0 bytes (and any other value).

Anything I've tried that keeps track of the count of bytes written (like Vec<u8>, Cursor, etc) can't tell me, the caller, how many bytes were written because the function I'm calling takes ownership of the value, and so anything after that from the caller falls foul of ownership rules.

At present, the least-worst option I can think of, short of modifying ciborium (or more drastic options, like great piles of pointer-mangling unsafe code) is to create a pipe, passing the writer half to ciborium, and reading the data out the reader half. Which is... hideous.

Am I missing something really obvious, or am I totally out of luck here?

Write is implemented for Vec<u8> as well as &mut W where W: Write. Combining the two means that &mut Vec<u8> is Write. You can use that to retain ownership of the Vec.

John's answer is probably the most straightforward, but I wanted to provide an alternative that uses an array as in your question.

The Write implementation for &mut [u8] updates the slice to point to the yet-unwritten part, so the difference in length between the two slices tells you how many bytes were written:

use std::io::Write;

fn write_something(mut w: impl Write) -> std::io::Result<()> {
    w.write_all(b"foobar")
}

fn main() -> std::io::Result<()> {
    let mut b = [0u8; 20];
    
    let written = b.len() - {
        let mut s = &mut b[..];

        write_something(&mut s)?;
        write_something(&mut s)?;

        s.len()
    };

    assert_eq!(written, 12);
    assert_eq!(&b[..written], b"foobarfoobar");
    
    Ok(())
}

(Playground)