Struct OwnedCursor

pub struct OwnedCursor { /* private fields */ }

A write-only cursor over an OwnedBuf.

Created via OwnedBuf::unfilled or using Into.

An OwnedCursor represents the unfilled portion of an OwnedBuf, as data is filled it becomes inaccessible via the cursor, so the start of the cursor (or current position, if you think of it that way) is always the first unfilled byte of the underlying buffer. An OwnedCursor can contain both initialized and uninitialized bytes.

An OwnedCursor takes ownership of the OwnedBuf when it is created. It can always be converted back into and OwnedBuf.

Implementations

impl OwnedCursor

pub fn into_buf(self) -> OwnedBuf

Convert this cursor back into its underlying buffer.

pub fn capacity(&self) -> usize

Returns the available space in the cursor.

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

Returns a mutable reference to the initialized portion of the cursor.

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

Returns a mutable reference to the uninitialized part of the cursor.

It is safe to uninitialize any of these bytes.

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

Returns a mutable reference to the whole cursor.

Safety

The caller must not uninitialize any bytes in the initialized portion of the cursor.

pub unsafe fn advance(&mut self, n: usize) -> &mut Self

Advance the cursor by asserting that n bytes have been filled.

After advancing, the n bytes are no longer accessible via the cursor and can only be accessed via the underlying buffer. I.e., the buffer’s filled portion grows by n elements and its unfilled portion (and the capacity of this cursor) shrinks by n elements.

Safety

The caller must ensure that the first n bytes of the cursor have been properly initialised.

pub fn ensure_init(&mut self) -> &mut Self

Initializes all bytes in the cursor.

pub unsafe fn set_init(&mut self, n: usize) -> &mut Self

Asserts that the first n unfilled bytes of the cursor are initialized.

OwnedBuf assumes that bytes are never de-initialized, so this method does nothing when called with fewer bytes than are already known to be initialized.

Safety

The caller must ensure that the first n bytes of the cursor have already been initialized.

pub fn write_slice(&mut self, data: &[u8])

Copies data to the start of the cursor and advances the cursor.

Panics

Panics if self.capacity() is less than data.len().

Trait Implementations

impl Into<OwnedCursor> for OwnedBuf

fn into(self) -> OwnedCursor

Converts this type into the (usually inferred) input type.

impl Write for OwnedCursor

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

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

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.