Struct ioslice::IoSliceMut

#[repr(transparent)]pub struct IoSliceMut<'a, I: Initialization = Initialized> { /* fields omitted */ }

A #![no_std]-friendly wrapper over the std::io::IoSliceMut.

Internally, the struct will store the following based on crate features:

• std - wrapping std::io::IoSliceMut directly, with accessors for it as well as conversion functions and From impls.
• libc (with #[cfg(unix)] - wrapping [libc::iovec] directly on platforms that support it, together with a marker making rustc think this stores a &'a mut [u8].
• (none) - wrapping a regular slice, that may not have the same ABI guarantees as the types from std or libc have.

Implementations

impl<'a, I: Initialization> IoSliceMut<'a, I>

pub fn new(slice: &'a mut [u8]) -> Self

Construct a new mutable I/O slice, from an existing initialized slice. The initializedness is determined based on the generic parameter I, while the original slice obviously has to be initialized since its type is u8 and not [MaybeUninit<u8>].

pub unsafe fn assume_init(self) -> IoSliceMut<'a, Initialized>

Unsafely cast a possibly uninitialized slice into an initialized slice.

NOTE: THIS MUST NOT BE USED FOR INITIALIZATION; THAT IS DIRECT UB

Safety

For this to be safe, the initialization invariant must be upheld. Refer to the std::mem::MaybeUninit docs.

pub unsafe fn assume_init_ref(&self) -> &IoSliceMut<'a, Initialized>

Unsafely cast a possibly uninitialized slice into an initialized slice, by reference.

Safety

This must uphold the initialization invariant.

pub unsafe fn assume_init_mut(&mut self) -> &mut IoSliceMut<'a, Initialized>

Unsafely cast a possibly uninitialized slice into an initialized slice, by mutable reference.

Safety

This must uphold the initialization invariant.

pub fn into_uninit(self) -> IoSliceMut<'a, Uninitialized>

Cast an I/O slice, being Initialized or not, into an Uninitialized I/O slice.

pub fn as_uninit(&self) -> &IoSliceMut<'a, Uninitialized>

Cast an I/O slice, being Initialized or not, into an Uninitialized I/O slice, by reference.

pub fn as_uninit_mut(&mut self) -> &mut IoSliceMut<'a, Uninitialized>

Cast an I/O slice, being Initialized or not, into an Uninitialized I/O slice, by mutable reference.

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

Advance the start offset of a single slice by count bytes, reducing the length as well.

Panics

This will panic if count is greater than the current length.

#[must_use]pub fn advance_within(slices: &mut [Self], n: usize) -> Option<&mut [Self]>

Advance multiple slices by n, skipping and truncating slices until there are n less total bytes.

They are always advanced from start to end, and only the last slice will actually be changed if the count turned out to be uneven. None is returned if n turns out to be greater than the total length of the slices, so that counting beforehand becomes unnecessary.

pub fn inner_data(&self) -> &[I::DerefTargetItem]

Retrieve the "inner data" immutably, pointed to by the I/O slice, being to either &[u8] or &[MaybeUninit<u8>] depending on the generic type parameter I.

pub fn inner_data_mut(&mut self) -> &mut [I::DerefTargetItem]

Retrieve the "inner data" mutably, pointed to by the I/O slice, being to either &mut [u8] or &mut [MaybeUninit<u8>] depending on the generic type parameter I.

pub fn into_inner_data(self) -> &'a mut [I::DerefTargetItem]

Get the "inner data" mutably, but with the lifetime 'a rather than the lifetime of self.

pub fn from_inner_data(inner_data: &'a mut [I::DerefTargetItem]) -> Self

Convert a regular slice that points to either u8 or MaybeUninit<u8>, into IoSliceMut.

pub fn as_maybe_uninit_slice(&self) -> &[MaybeUninit<u8>]

pub fn as_maybe_uninit_slice_mut(&mut self) -> &mut [MaybeUninit<u8>]

#[must_use]pub fn zeroed(self) -> IoSliceMut<'a, Initialized>

#[must_use]pub fn zeroed_by_ref<'b>(&'b mut self) -> &'b mut IoSliceMut<'a, Initialized>

impl<'a> IoSliceMut<'a, Initialized>

pub fn as_slice(&self) -> &[u8]

Retrieve the inner slice immutably. This requires the I/O slice to be initialized.

Unlike the immutable IoSlice, this will require a secondary lifetime of self, to prevent aliasing when the data can be mutated. If it is necessary to obtain a byte slice with lifetime 'a, use to_slice.

pub fn into_slice(self) -> &'a [u8]

Take an IoSliceMut by value, turning it into an immutable byte slice of lifetime 'a.

pub fn as_slice_mut(&mut self) -> &mut [u8]

Retrieve the inner slice mutably. This requires the I/O slice to be initialized.

Note that unlike into_slice_mut, this will have the lifetime of self, not 'a.

pub fn into_slice_mut(self) -> &'a mut [u8]

Take an IoSliceMut by value, turning it into a mutable byte slice of lifetime 'a.

pub fn cast_to_std_ioslices<'b>(slices: &'b [Self]) -> &'b [IoSlice<'a>]

Cast &[IoSliceMut] to &[std::io::IoSlice].

pub fn cast_to_std_mut_ioslices<'b>(slices: &'b [Self]) -> &'b [IoSliceMut<'a>]

Cast &[IoSliceMut] to &[std::io::IoSliceMut].

pub fn cast_to_std_ioslices_mut<'b>(
    slices: &'b mut [Self]
) -> &'b mut [IoSlice<'a>]

Cast &mut [IoSliceMut] to &mut [std::io::IoSlice].

pub fn cast_to_std_mut_ioslices_mut(
    slices: &'a mut [Self]
) -> &'a mut [IoSliceMut<'a>]

Cast &mut [IoSliceMut] to &mut [std::io::IoSliceMut].

Trait Implementations

impl<'a, I: Initialization> AsMut<[<I as Initialization>::DerefTargetItem]> for IoSliceMut<'a, I>

fn as_mut(&mut self) -> &mut [I::DerefTargetItem]

Performs the conversion.

impl<'a, I: Initialization> AsRef<[<I as Initialization>::DerefTargetItem]> for IoSliceMut<'a, I>

fn as_ref(&self) -> &[I::DerefTargetItem]

Performs the conversion.

impl<'a, I: Initialization> Borrow<[<I as Initialization>::DerefTargetItem]> for IoSliceMut<'a, I>

fn borrow(&self) -> &[I::DerefTargetItem]

Immutably borrows from an owned value.

impl<'a, I: Initialization> BorrowMut<[<I as Initialization>::DerefTargetItem]> for IoSliceMut<'a, I>

fn borrow_mut(&mut self) -> &mut [I::DerefTargetItem]

Mutably borrows from an owned value.

impl<'a, I: Initialization> Debug for IoSliceMut<'a, I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, I: Initialization> Deref for IoSliceMut<'a, I>

type Target = [I::DerefTargetItem]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, I: Initialization> DerefMut for IoSliceMut<'a, I>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a> Eq for IoSliceMut<'a, Initialized>

impl<'a, I: Initialization> From<&'a mut [<I as Initialization>::DerefTargetItem]> for IoSliceMut<'a, I>

fn from(slice: &'a mut [I::DerefTargetItem]) -> Self

Performs the conversion.

impl<'a> From<&'a mut [u8]> for IoSliceMut<'a, Uninitialized>

fn from(slice: &'a mut [u8]) -> Self

Performs the conversion.

impl<'a> Hash for IoSliceMut<'a, Initialized>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for IoSliceMut<'a, Initialized>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'a> PartialEq<[u8]> for IoSliceMut<'a, Initialized>

fn eq(&self, other: &[u8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b> PartialEq<IoSlice<'b, Initialized>> for IoSliceMut<'a, Initialized>

fn eq(&self, other: &IoSlice<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<IoSliceMut<'a, Initialized>> for IoSliceMut<'a, Initialized>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b> PartialEq<IoSliceMut<'b, Initialized>> for IoSlice<'a, Initialized>

fn eq(&self, other: &IoSliceMut<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialOrd<[u8]> for IoSliceMut<'a, Initialized>

fn partial_cmp(&self, other: &[u8]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, 'b> PartialOrd<IoSlice<'b, Initialized>> for IoSliceMut<'a, Initialized>

fn partial_cmp(&self, other: &IoSlice<'b, Initialized>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> PartialOrd<IoSliceMut<'a, Initialized>> for IoSliceMut<'a, Initialized>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, 'b> PartialOrd<IoSliceMut<'b, Initialized>> for IoSlice<'a, Initialized>

fn partial_cmp(&self, other: &IoSliceMut<'b>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, I: Initialization> RefUnwindSafe for IoSliceMut<'a, I>

impl<'a, I: Initialization> Send for IoSliceMut<'a, I>

impl<'a, I: Initialization> Sync for IoSliceMut<'a, I>

impl<'a, I: Initialization> Unpin for IoSliceMut<'a, I>

impl<'a, I: Initialization> UnwindSafe for IoSliceMut<'a, I>