Struct IoBuffersMut 

pub struct IoBuffersMut<Buffers> { /* private fields */ }

An owned writable scatter/gather package with I/O vectors prepared once. Like IoBuffers, it retains the complete source sequence and supports explicit advancement after retirement.

Access to the source owner is limited to into_inner(): modifying or resizing source owners while cached vectors exist could invalidate their pointers. Read and write access to active bytes goes through the sequence traits instead.

Prepared writable vectors cannot escape their exclusive package borrow:

use base_scheduler::{IoBuffersMut, IoBufSequenceMut};
let mut buffers = IoBuffersMut::new([vec![0; 4]]);
let vectors = buffers.io_slices_mut().unwrap();
let owner = buffers.into_inner();
assert_eq!(vectors[0].len(), 4);

Implementations

impl<Buffers: IoBufSequenceMut> IoBuffersMut<Buffers>

pub fn new(buffers: Buffers) -> Self

Prepare writable vectors once and retain the original sequence. This allocates vector storage once; ordinary operations and advancement reuse it without allocation.

Panics on Windows if an individual byte range exceeds the IoSlice/IoSliceMut 4 GiB limit.

pub fn advance(&mut self, bytes: usize)

Advance active byte ranges explicitly after a completed operation, without copying payloads or rebuilding vectors. Panics without changing the package if bytes exceeds the remaining length. Advancing by zero skips leading empty vectors.

pub fn into_inner(self) -> Buffers

Recover all original source owners and ranges, including received bytes in consumed ranges.

Trait Implementations

impl<Buffers: IoBufSequenceMut> IoBufSequence for IoBuffersMut<Buffers>

fn buffer_count(&self) -> usize

Number of active byte ranges, including empty ranges.

fn buffer(&self, index: usize) -> &[u8]

Borrow an active initialized byte range. Panics if index is out of bounds.

fn io_slices(&self) -> Option<&[IoSlice<'_>]>

Borrow prepared I/O vectors, when available. These must describe exactly the same ranges as buffer(). Backends can otherwise build vectors in their own reusable storage.

impl<Buffers: IoBufSequenceMut> IoBufSequenceMut for IoBuffersMut<Buffers>

fn buffer_mut(&mut self, index: usize) -> &mut [u8]

Borrow an active writable byte range. Panics if index is out of bounds.

fn io_slices_mut(&mut self) -> Option<&[IoSliceMut<'_>]>

Borrow prepared writable I/O vectors, when available. The shared outer slice prevents replacing vectors or changing ranges; the exclusive sequence borrow permits a backend to write through their native pointers until retirement.